From e7b062c88dcb0c5eec393b757afe13d8202d11cc Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:09:07 +0300
Subject: [PATCH 01/12] fix: land on the dashboard after signing in

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 SW.Bitween.Web/ClientApp/e2e/login.spec.ts | 26 ++++++++++++++++++++++
 SW.Bitween.Web/ClientApp/src/nav.ts        | 13 ++++++++++-
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/SW.Bitween.Web/ClientApp/e2e/login.spec.ts b/SW.Bitween.Web/ClientApp/e2e/login.spec.ts
index 4ce0863a..da909f0a 100644
--- a/SW.Bitween.Web/ClientApp/e2e/login.spec.ts
+++ b/SW.Bitween.Web/ClientApp/e2e/login.spec.ts
@@ -1,4 +1,5 @@
 import { test, expect, type Page } from "@playwright/test";
+import { ADMIN_EMAIL, ADMIN_PASSWORD, signInAsAdmin } from "./helpers";
 
 /**
  * What the sign-in page offers is driven by the anonymous config endpoint. These tests rewrite
@@ -46,3 +47,28 @@ test("Microsoft-only with no Microsoft app configured explains itself", async ({
   await expect(passwordField(page)).toHaveCount(0);
   await expect(microsoftButton(page)).toHaveCount(0);
 });
+
+/**
+ * Where signing in leaves you. Two different answers, which is the point of testing both: an
+ * operator opening the app wants to see how the system is doing, but somebody who followed a
+ * link — or whose token expired mid-task — wants the page they were going to, not a detour.
+ */
+test("signing in with nowhere to go lands on the dashboard", async ({ page }) => {
+  await signInAsAdmin(page);
+
+  await expect(page).toHaveURL(/\/dashboard$/);
+  await expect(page.getByRole("heading", { name: "Dashboard" })).toBeVisible();
+});
+
+test("signing in to reach a page lands on that page, not the dashboard", async ({ page }) => {
+  // Arriving cold at a protected URL — a link from a colleague, or a reload after the token
+  // expired. The guard sends it to login and login has to give it back.
+  await page.goto("partners");
+  await page.waitForURL((url) => url.pathname.endsWith("/login"));
+
+  await page.fill("#login-email", ADMIN_EMAIL);
+  await page.fill("#login-password", ADMIN_PASSWORD);
+  await page.getByRole("button", { name: "Sign in" }).click();
+
+  await expect(page).toHaveURL(/\/partners$/);
+});
diff --git a/SW.Bitween.Web/ClientApp/src/nav.ts b/SW.Bitween.Web/ClientApp/src/nav.ts
index 3b36679c..5a02ff16 100644
--- a/SW.Bitween.Web/ClientApp/src/nav.ts
+++ b/SW.Bitween.Web/ClientApp/src/nav.ts
@@ -118,8 +118,19 @@ export const visibleGroups = (permissions: PermissionKey[]): NavGroup[] =>
     (g) => g.items.length > 0,
   );
 
-/** Where to land after signing in: the first page this session can see. */
+/**
+ * Where to land after signing in with nowhere particular to go.
+ *
+ * The dashboard, which is deliberately not in the sidebar — reached from the logo — so the
+ * rule below would never pick it. Landing there is the one moment it is the obviously right
+ * page: you have just arrived and want to know how the system is doing before going anywhere.
+ *
+ * Signing in *to get somewhere* is a different thing and does not come through here: the guard
+ * remembers the page it turned away and login returns to it, so an expired session and a link
+ * from a colleague both still end where they were headed.
+ */
 export const homePath = (session: Session): string => {
+  if (session.permissions.includes("dashboard.view")) return "/dashboard";
   const groups = visibleGroups(session.permissions);
   return groups[0]?.items[0]?.path ?? "/profile";
 };

From 6e572bbab59df3b1a602b45fb980546e3f293949 Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:09:16 +0300
Subject: [PATCH 02/12] fix: put adapter fields above the mapper editor link

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../src/components/config/AdapterConfig.tsx   | 42 +++++++++----------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/SW.Bitween.Web/ClientApp/src/components/config/AdapterConfig.tsx b/SW.Bitween.Web/ClientApp/src/components/config/AdapterConfig.tsx
index 4fe48658..9555e8e7 100644
--- a/SW.Bitween.Web/ClientApp/src/components/config/AdapterConfig.tsx
+++ b/SW.Bitween.Web/ClientApp/src/components/config/AdapterConfig.tsx
@@ -515,27 +515,6 @@ export function AdapterConfig({
           )}
         </div>
       </div>
-      {adapter && adapter.props.length > 0 && (
-        /*
-          Two columns are decided by how wide *this* box is, not how wide the window is.
-          A `sm:` breakpoint reads the viewport, so a 360px side panel on a 2000px screen
-          still got two columns, and every email address wrapped onto three lines. The
-          container query asks the box instead, so a narrow one simply stacks.
-        */
-        <div className="@container space-y-4">
-          {requiredProps.length > 0 && (
-            <div className="grid gap-4 @lg:grid-cols-2">{requiredProps.map(renderProp)}</div>
-          )}
-          {optionalProps.length > 0 && (
-            <div className="border-t border-ink-100 pt-4">
-              <p className="mb-2.5 text-[11px] font-medium tracking-wide text-ink-400 uppercase">
-                Optional · {optionalProps.length} field{optionalProps.length === 1 ? "" : "s"}
-              </p>
-              <div className="grid gap-4 @lg:grid-cols-2">{optionalProps.map(renderProp)}</div>
-            </div>
-          )}
-        </div>
-      )}
       {adapter && usesVisualMappingEditor(adapter.id) && (
         onOpenMapperEditor ? (
           <button
@@ -564,6 +543,27 @@ export function AdapterConfig({
           </p>
         )
       )}
+      {adapter && adapter.props.length > 0 && (
+        /*
+          Two columns are decided by how wide *this* box is, not how wide the window is.
+          A `sm:` breakpoint reads the viewport, so a 360px side panel on a 2000px screen
+          still got two columns, and every email address wrapped onto three lines. The
+          container query asks the box instead, so a narrow one simply stacks.
+        */
+        <div className="@container space-y-4">
+          {requiredProps.length > 0 && (
+            <div className="grid gap-4 @lg:grid-cols-2">{requiredProps.map(renderProp)}</div>
+          )}
+          {optionalProps.length > 0 && (
+            <div className="border-t border-ink-100 pt-4">
+              <p className="mb-2.5 text-[11px] font-medium tracking-wide text-ink-400 uppercase">
+                Optional · {optionalProps.length} field{optionalProps.length === 1 ? "" : "s"}
+              </p>
+              <div className="grid gap-4 @lg:grid-cols-2">{optionalProps.map(renderProp)}</div>
+            </div>
+          )}
+        </div>
+      )}
     </div>
   );
 }

From 5034570d2211eedd07711af3533363e730de30e5 Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:09:16 +0300
Subject: [PATCH 03/12] fix: withhold adapter credentials from the subscription
 list
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The list endpoint returned every integration's adapter properties in
cleartext. They stay in the query — the property-value filter searches
them — and are emptied before the response is shaped.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../Resources/Subscriptions/Search.cs         | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/SW.Bitween.Api/Resources/Subscriptions/Search.cs b/SW.Bitween.Api/Resources/Subscriptions/Search.cs
index 77ffc517..dc09f988 100644
--- a/SW.Bitween.Api/Resources/Subscriptions/Search.cs
+++ b/SW.Bitween.Api/Resources/Subscriptions/Search.cs
@@ -105,6 +105,7 @@ join document in _dbContext.Set<Document>() on subscriber.DocumentId equals docu
             var result = await query.Search(searchyRequest.Conditions, searchyRequest.Sorts, searchyRequest.PageSize,
                 searchyRequest.PageIndex).ToListAsync();
             await AttachSchedules(result);
+            StripAdapterProperties(result);
 
             return new SearchyResponse<SubscriptionSearch>
             {
@@ -113,6 +114,36 @@ join document in _dbContext.Set<Document>() on subscriber.DocumentId equals docu
             };
         }
 
+        /// <summary>Empties the adapter property collections on every returned row.</summary>
+        /// <remarks>
+        /// Adapter properties hold credentials — a storage key, an OAuth secret, the password for a
+        /// partner system. <c>Subscriptions/Get</c> replaces those with a sentinel before answering;
+        /// this list endpoint returned them verbatim, which put every integration's secrets one
+        /// request away from anyone allowed to see the list at all.
+        /// <para>
+        /// Emptied here rather than left out of the projection because the projection needs them:
+        /// the <c>rawsubscriptionproperties</c> filter searches inside their values, in memory, over
+        /// the rows this query produced. So they are loaded, used, and then dropped before the
+        /// response is shaped. Nothing reads them off this endpoint — both UIs configure a
+        /// subscription from <c>Subscriptions/Get</c>, and the list has never shown them.
+        /// </para>
+        /// <para>
+        /// Emptied rather than masked because masking can only hide what an adapter declares
+        /// <c>[Secure]</c>, and the external adapters declare nothing — masking here would have
+        /// looked like a fix while leaving those integrations exactly as exposed.
+        /// </para>
+        /// </remarks>
+        private static void StripAdapterProperties(List<SubscriptionSearch> rows)
+        {
+            foreach (var row in rows)
+            {
+                row.HandlerProperties = [];
+                row.MapperProperties = [];
+                row.ReceiverProperties = [];
+                row.ValidatorProperties = [];
+            }
+        }
+
         /// <summary>Fills in each returned row's schedules.</summary>
         /// <remarks>
         /// A second query rather than part of the projection above: <c>Schedule.On</c> is a
@@ -185,6 +216,7 @@ private async Task<SearchyResponse<SubscriptionSearch>> SearchWithEdgeCases(
             var page = data.Skip(searchyRequest.PageSize * searchyRequest.PageIndex)
                 .Take(searchyRequest.PageSize).ToList();
             await AttachSchedules(page);
+            StripAdapterProperties(page);
 
             return new SearchyResponse<SubscriptionSearch>
             {

From ae1b0b40edd757dd9b89bc81e3981b027f5b6372 Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:09:16 +0300
Subject: [PATCH 04/12] fix: withhold the default vendor link from the pre-auth
 config

The sign-in page reads this endpoint before anyone authenticates, and
the shipped GitHub link led a penetration test to our public source. A
link a deployment chose is still returned.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 SW.Bitween.Api/Resources/Settings/Config.cs | 49 ++++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

diff --git a/SW.Bitween.Api/Resources/Settings/Config.cs b/SW.Bitween.Api/Resources/Settings/Config.cs
index c8e2ccc3..c6c5bff9 100644
--- a/SW.Bitween.Api/Resources/Settings/Config.cs
+++ b/SW.Bitween.Api/Resources/Settings/Config.cs
@@ -1,3 +1,6 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using SW.Bitween.Services;
 using SW.PrimitiveTypes;
@@ -8,8 +11,30 @@ namespace SW.Bitween.Resources.Settings;
 [HandlerName("Config")]
 public class Config(BitweenOptions BitweenOptions, ThemeOptions themeOptions) : IQueryHandler<object>
 {
+    /// <summary>
+    /// Brand links that name the vendor rather than the deployment, and so are withheld while they
+    /// still hold the value we shipped.
+    /// </summary>
+    /// <remarks>
+    /// This endpoint answers before anyone signs in, because the sign-in page brands itself from
+    /// it. A penetration test followed the default <c>GithubLink</c> from here to our public
+    /// repository, and from there to the sample signing key and the default administrator password
+    /// — the whole chain started with a link nobody had configured.
+    /// <para>
+    /// Withheld only at the default: a deployment that sets its own link is publishing its own
+    /// address and gets it back untouched. So the footer keeps working wherever it was meant to,
+    /// and stops pointing strangers at our source everywhere else.
+    /// </para>
+    /// </remarks>
+    private static readonly string[] VendorLinks = ["GithubLink"];
+
     public async Task<object> Handle()
     {
+        var defaults = new ThemeOptions();
+        var withheld = VendorLinks
+            .Where(name => Equals(Read(themeOptions, name), Read(defaults, name)))
+            .ToHashSet(StringComparer.Ordinal);
+
         return new
         {
             BitweenOptions.MsalClientId,
@@ -19,10 +44,32 @@ public async Task<object> Handle()
             IsRabbitMqManagementConfigured = !string.IsNullOrWhiteSpace(BitweenOptions.RabbitMqManagementUrl)
                                              && !string.IsNullOrWhiteSpace(BitweenOptions.RabbitMqManagementUsername)
                                              && !string.IsNullOrWhiteSpace(BitweenOptions.RabbitMqManagementPassword),
-            Theme = themeOptions,
+            Theme = ThemeWithout(withheld),
             // The product defaults, so the sign-in page — which has no session and can't read the
             // settings list — can tell a brand value someone chose from one nobody has touched.
             ThemeDefaults = SettingsService.DefaultsUnder("Theme.")
+                .Where(kv => !withheld.Contains(Pascalize(kv.Key)))
+                .ToDictionary(kv => kv.Key, kv => kv.Value)
         };
     }
+
+    /// <summary>
+    /// The theme as a dictionary so a key can be left out of it.
+    /// </summary>
+    /// <remarks>
+    /// Built by reflection rather than written out property by property: a hand-written projection
+    /// silently drops whatever is added to <see cref="ThemeOptions"/> next, and the symptom — one
+    /// brand value that will not apply — looks nothing like its cause.
+    /// </remarks>
+    private Dictionary<string, object?> ThemeWithout(IReadOnlySet<string> withheld) =>
+        typeof(ThemeOptions).GetProperties()
+            .Where(p => p.CanRead && !withheld.Contains(p.Name))
+            .ToDictionary(p => Camelize(p.Name), p => p.GetValue(themeOptions));
+
+    private static object? Read(ThemeOptions theme, string propertyName) =>
+        typeof(ThemeOptions).GetProperty(propertyName)?.GetValue(theme);
+
+    private static string Camelize(string name) => char.ToLowerInvariant(name[0]) + name[1..];
+
+    private static string Pascalize(string name) => char.ToUpperInvariant(name[0]) + name[1..];
 }

From 7c71bb3be8b67d4d3e49514b9bc952f3da33b054 Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:09:25 +0300
Subject: [PATCH 05/12] feat: require a new password from the seeded admin

Every installation is seeded with the same administrator, whose password
is published in our repository. Until it is replaced its token grants
nothing and the app offers only the change-password screen.

The migration flags the account only where the stored password is still
that one, so an installation that already changed it is untouched.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 SW.Bitween.Api/Data/BitweenDbContext.cs       |    6 +-
 SW.Bitween.Api/Domain/Accounts/Account.cs     |   15 +
 .../Extensions/AccountExtensions.cs           |    6 +
 .../Extensions/RequestContextExtensions.cs    |   34 +-
 SW.Bitween.Api/Resources/Accounts/Login.cs    |   10 +-
 SW.Bitween.Api/Resources/Accounts/Profile.cs  |    3 +-
 ...15090333_AddMustChangePassword.Designer.cs | 2395 ++++++++++++++
 .../20260915090333_AddMustChangePassword.cs   |   46 +
 .../BitweenDbContextModelSnapshot.cs          |    4 +
 ...15090329_AddMustChangePassword.Designer.cs | 2388 ++++++++++++++
 .../20260915090329_AddMustChangePassword.cs   |   46 +
 .../BitweenDbContextModelSnapshot.cs          |    4 +
 SW.Bitween.PgSql/BitweenDbContext.cs          |    6 +-
 ...15090259_AddMustChangePassword.Designer.cs | 2750 +++++++++++++++++
 .../20260915090259_AddMustChangePassword.cs   |   48 +
 .../BitweenDbContextModelSnapshot.cs          |    5 +
 SW.Bitween.Sdk/Model/Account.cs               |    8 +
 .../ClientApp/src/api/http/session.ts         |    2 +
 SW.Bitween.Web/ClientApp/src/api/types.ts     |    6 +
 SW.Bitween.Web/ClientApp/src/auth/guards.tsx  |    5 +
 .../src/pages/auth/ChangePassword.tsx         |  102 +
 SW.Bitween.Web/ClientApp/src/router.tsx       |    4 +
 22 files changed, 7884 insertions(+), 9 deletions(-)
 create mode 100644 SW.Bitween.MsSql/Migrations/20260915090333_AddMustChangePassword.Designer.cs
 create mode 100644 SW.Bitween.MsSql/Migrations/20260915090333_AddMustChangePassword.cs
 create mode 100644 SW.Bitween.MySql/Migrations/20260915090329_AddMustChangePassword.Designer.cs
 create mode 100644 SW.Bitween.MySql/Migrations/20260915090329_AddMustChangePassword.cs
 create mode 100644 SW.Bitween.PgSql/Migrations/20260915090259_AddMustChangePassword.Designer.cs
 create mode 100644 SW.Bitween.PgSql/Migrations/20260915090259_AddMustChangePassword.cs
 create mode 100644 SW.Bitween.Web/ClientApp/src/pages/auth/ChangePassword.tsx

diff --git a/SW.Bitween.Api/Data/BitweenDbContext.cs b/SW.Bitween.Api/Data/BitweenDbContext.cs
index 4efef63e..11f53962 100644
--- a/SW.Bitween.Api/Data/BitweenDbContext.cs
+++ b/SW.Bitween.Api/Data/BitweenDbContext.cs
@@ -479,7 +479,11 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                         Password = defaultPasswordHash,
                         Deleted = false,
                         Role = AccountRole.Admin,
-                        FailedLoginCount = 0
+                        FailedLoginCount = 0,
+                        // True for a fresh installation, whose password is the published default.
+                        // Installations that already exist are handled by the migration, which
+                        // flags only those still holding that same value.
+                        MustChangePassword = true
                     });
             });
 
diff --git a/SW.Bitween.Api/Domain/Accounts/Account.cs b/SW.Bitween.Api/Domain/Accounts/Account.cs
index 01e3b2ce..eadb08fe 100644
--- a/SW.Bitween.Api/Domain/Accounts/Account.cs
+++ b/SW.Bitween.Api/Domain/Accounts/Account.cs
@@ -31,6 +31,19 @@ public Account(string displayName, string email, string password, AccountRole ro
         public int FailedLoginCount { get; private set; }
         public DateTime? LockoutEnd { get; private set; }
 
+        /// <summary>
+        /// Set while the account still has a password nobody chose. Signing in works, but the token
+        /// it returns grants nothing until the password is replaced.
+        /// </summary>
+        /// <remarks>
+        /// This exists for one account: the administrator seeded into every installation, whose
+        /// password ships in our public repository. On installations where it was never changed,
+        /// that published value was full administrative access to anyone who read the repository.
+        /// A migration sets this only where the stored password is still that one, so an
+        /// installation that changed it years ago notices nothing.
+        /// </remarks>
+        public bool MustChangePassword { get; private set; }
+
         public bool IsLockedOut(DateTime nowUtc) => LockoutEnd.HasValue && LockoutEnd.Value > nowUtc;
 
         public void RegisterSuccessfulLogin()
@@ -71,6 +84,8 @@ private bool AddLoginMethod(LoginMethod loginMethod)
         public void SetPassword(string password)
         {
             Password = SecurePasswordHasher.Hash(password);
+            // Whoever set this one chose it, which is the whole requirement.
+            MustChangePassword = false;
         }
 
 
diff --git a/SW.Bitween.Api/Extensions/AccountExtensions.cs b/SW.Bitween.Api/Extensions/AccountExtensions.cs
index a647579e..e160fd12 100644
--- a/SW.Bitween.Api/Extensions/AccountExtensions.cs
+++ b/SW.Bitween.Api/Extensions/AccountExtensions.cs
@@ -89,6 +89,12 @@ private static ClaimsIdentity CreateClaimsIdentity(this Account account, LoginMe
 
             if (account.Email != null) claims.Add(new Claim(ClaimTypes.Email, account.Email));
 
+            // Carried on the token rather than read per request like permissions are: it decides
+            // what the token itself is worth, and a token has to keep meaning the same thing for
+            // as long as it is valid.
+            if (account.MustChangePassword)
+                claims.Add(new Claim(RequestContextExtensions.MustChangePasswordClaim, "true"));
+
 
             return new ClaimsIdentity(claims, "Bitween");
         }
diff --git a/SW.Bitween.Api/Extensions/RequestContextExtensions.cs b/SW.Bitween.Api/Extensions/RequestContextExtensions.cs
index 93f5bb8f..cb3ccc06 100644
--- a/SW.Bitween.Api/Extensions/RequestContextExtensions.cs
+++ b/SW.Bitween.Api/Extensions/RequestContextExtensions.cs
@@ -11,13 +11,34 @@ namespace SW.Bitween
     public static class RequestContextExtensions
     {
         /// <summary>
-        /// Marks the break-glass token minted by POST /login from configured AdminCredentials. That
-        /// token has no account behind it, so its grants can't be resolved from the database. It
-        /// used to clear every check only because the old role guard failed open on a missing
-        /// claim; this claim makes the same grant deliberate instead of accidental.
+        /// Grants everything to an identity with no account behind it, so there are no roles to
+        /// resolve from the database. Only the integration test fixture mints it.
         /// </summary>
+        /// <remarks>
+        /// It used to mark the token from <c>POST /login</c>, which signed in against a username
+        /// and password held in configuration. That defaulted to a working pair published in our
+        /// public repository, neither UI ever called it, and a penetration test used it to take
+        /// full control of a deployment. The endpoint is gone.
+        /// <para>
+        /// The claim stays because it is how a caller with no account is granted anything at all.
+        /// Minting one needs the signing key, which is enough to impersonate anybody anyway.
+        /// </para>
+        /// </remarks>
         public const string SuperuserClaim = "bitween_superuser";
 
+        /// <summary>
+        /// Present on a token issued to an account whose password nobody has chosen. Such a token
+        /// authenticates but grants nothing, so the account can reach self-service — changing the
+        /// password — and nothing else.
+        /// </summary>
+        /// <remarks>
+        /// A sign-in has to succeed for the password to be changeable at all: the change requires
+        /// the current password and the caller's own identity, so refusing the sign-in outright
+        /// would leave the account with no way out but an administrator who may not exist. Granting
+        /// nothing is the same thing said in the only place that can act on it.
+        /// </remarks>
+        public const string MustChangePasswordClaim = "bitween_must_change_password";
+
         /// <summary>
         /// Throws unless the caller holds at least one of <paramref name="anyOf"/>. This is really a
         /// "forbidden" — the caller is signed in and simply isn't allowed — but CqApi renders
@@ -49,6 +70,11 @@ public static async Task<bool> HasPermission(this RequestContext requestContext,
         public static async Task<HashSet<string>> GetPermissions(this RequestContext requestContext,
             BitweenDbContext dbContext)
         {
+            // Checked ahead of everything, superuser included: a password nobody chose is not a
+            // basis for any grant, whatever else the token claims.
+            if (requestContext.User?.FindFirst(MustChangePasswordClaim) is not null)
+                return [];
+
             if (requestContext.User?.FindFirst(SuperuserClaim) is not null)
                 return PermissionCatalog.AllKeys.ToHashSet();
 
diff --git a/SW.Bitween.Api/Resources/Accounts/Login.cs b/SW.Bitween.Api/Resources/Accounts/Login.cs
index 4078788c..1e8d1152 100644
--- a/SW.Bitween.Api/Resources/Accounts/Login.cs
+++ b/SW.Bitween.Api/Resources/Accounts/Login.cs
@@ -162,8 +162,14 @@ await dbContext.Set<Account>()
                 Expires = DateTimeOffset.UtcNow.AddDays(30)
             });
 
-            // Return only the JWT — refresh token stays in the cookie, not in the response body
-            return new { Jwt = account.CreateJwt(LoginMethod.EmailAndPassword, jwtTokenParameters, jwtExpiryTimeSpan) };
+            // Return only the JWT — refresh token stays in the cookie, not in the response body.
+            // MustChangePassword rides along so the client can send them straight to the change
+            // form; the token grants nothing until they do, so this is a courtesy, not the control.
+            return new
+            {
+                Jwt = account.CreateJwt(LoginMethod.EmailAndPassword, jwtTokenParameters, jwtExpiryTimeSpan),
+                account.MustChangePassword
+            };
         }
 
         private string CreateRefreshToken(Account account, LoginMethod loginMethod)
diff --git a/SW.Bitween.Api/Resources/Accounts/Profile.cs b/SW.Bitween.Api/Resources/Accounts/Profile.cs
index 13f3e1ff..263a6c94 100644
--- a/SW.Bitween.Api/Resources/Accounts/Profile.cs
+++ b/SW.Bitween.Api/Resources/Accounts/Profile.cs
@@ -32,7 +32,8 @@ public async Task<object> Handle()
                 Name = a.DisplayName,
                 Id = a.Id,
                 Disabled = a.Disabled,
-                Role = a.Role.ToString()
+                Role = a.Role.ToString(),
+                MustChangePassword = a.MustChangePassword
             })
             .SingleOrDefaultAsync();
 
diff --git a/SW.Bitween.MsSql/Migrations/20260915090333_AddMustChangePassword.Designer.cs b/SW.Bitween.MsSql/Migrations/20260915090333_AddMustChangePassword.Designer.cs
new file mode 100644
index 00000000..d9fc92e9
--- /dev/null
+++ b/SW.Bitween.MsSql/Migrations/20260915090333_AddMustChangePassword.Designer.cs
@@ -0,0 +1,2395 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using SW.Bitween.MsSql;
+
+#nullable disable
+
+namespace SW.Bitween.MsSql.Migrations
+{
+    [DbContext(typeof(BitweenDbContext))]
+    [Migration("20260915090333_AddMustChangePassword")]
+    partial class AddMustChangePassword
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.19")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.HasSequence("DocumentIds");
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.Account", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("Disabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<byte>("EmailProvider")
+                        .HasColumnType("tinyint");
+
+                    b.Property<int>("FailedLoginCount")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LockoutEnd")
+                        .HasColumnType("datetime2");
+
+                    b.Property<byte>("LoginMethods")
+                        .HasColumnType("tinyint");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Password")
+                        .HasMaxLength(500)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Email")
+                        .IsUnique()
+                        .HasFilter("[Email] IS NOT NULL");
+
+                    b.ToTable("Accounts", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 9999,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Deleted = false,
+                            Disabled = false,
+                            DisplayName = "Admin",
+                            Email = "admin@Bitween.systems",
+                            EmailProvider = (byte)0,
+                            FailedLoginCount = 0,
+                            LoginMethods = (byte)2,
+                            MustChangePassword = true,
+                            Password = "$SWHASH$V1$10000$VQCi48eitH4Ml5juvBMOFZrMdQwBbhuIQVXe6RR7qJdDF2bJ",
+                            Role = 0
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.AccountRoleLink", b =>
+                {
+                    b.Property<int>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AccountId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AccountRoles", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.RefreshToken", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<byte>("LoginMethod")
+                        .HasColumnType("tinyint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("RefreshTokens", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Permissions")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Roles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Description = "Full access to everything, including members, roles and settings.",
+                            IsSystem = true,
+                            Name = "Administrator",
+                            Permissions = "[]"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Description = "Runs and configures integrations. Can't manage members, roles or settings.",
+                            IsSystem = true,
+                            Name = "Member",
+                            Permissions = "[]"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Description = "Read-only access to integrations, exchanges and configuration.",
+                            IsSystem = true,
+                            Name = "Viewer",
+                            Permissions = "[]"
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.AuditEntry", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(32)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(32)");
+
+                    b.Property<string>("Changes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CorrelationId")
+                        .IsRequired()
+                        .HasMaxLength(36)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(36)");
+
+                    b.Property<string>("EntityKey")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("EntityName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateTime>("OccurredOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("int");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<string>("UserId")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrelationId");
+
+                    b.HasIndex("OccurredOn");
+
+                    b.HasIndex("EntityName", "EntityKey", "OccurredOn");
+
+                    b.ToTable("AuditEntries", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Cluster.ClusterLease", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("AcquiredOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("OwnerNode")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<long>("Term")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ClusterLeases", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.AdapterState", b =>
+                {
+                    b.Property<string>("AdapterId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("InstanceKey")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Value")
+                        .HasMaxLength(8000)
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("AdapterId", "InstanceKey", "Name");
+
+                    b.ToTable("AdapterStates", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.DataSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AdapterId")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ConsecutiveFailures")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CpuLimitSamples")
+                        .HasColumnType("int");
+
+                    b.Property<double>("CpuPercentLimit")
+                        .HasColumnType("float");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("DeduplicationWindowDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("HardMemoryLimitMb")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastException")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("LastHeartbeatOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastKnownState")
+                        .HasMaxLength(100)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("OwnedByNode")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("Placement")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SecretProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("SoftMemoryLimitMb")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("DataSources", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.DataSourceStatement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("CursorColumn")
+                        .HasMaxLength(128)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(128)");
+
+                    b.Property<int>("DataSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("KeyColumn")
+                        .HasMaxLength(128)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(128)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Sql")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkGroupId");
+
+                    b.HasIndex("DataSourceId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("DataSourceStatements", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.InboundMessage", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(400)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(400)");
+
+                    b.Property<int>("DataSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("SeenOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("XchangeId")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSourceId");
+
+                    b.HasIndex("SeenOn");
+
+                    b.ToTable("InboundMessages", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DelayedRetry", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("On")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("On");
+
+                    b.ToTable("DelayedRetries", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Document", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValueSql("NEXT VALUE FOR [DocumentIds]");
+
+                    SqlServerPropertyBuilderExtensions.UseSequence(b.Property<int>("Id"), "DocumentIds");
+
+                    b.Property<bool>("BusEnabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("BusMessageTypeName")
+                        .HasMaxLength(500)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Code")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<bool?>("DisregardsUnfilteredMessages")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("DocumentFormat")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DuplicateInterval")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("PromotedProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("RetiredOn")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BusMessageTypeName")
+                        .IsUnique()
+                        .HasFilter("[BusMessageTypeName] IS NOT NULL");
+
+                    b.HasIndex("Code")
+                        .IsUnique()
+                        .HasFilter("[Code] IS NOT NULL");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Documents", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 10001,
+                            BusEnabled = false,
+                            DocumentFormat = 0,
+                            DuplicateInterval = 0,
+                            Name = "Aggregation Document",
+                            PromotedProperties = "{}"
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGateway", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("UrlName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UrlName")
+                        .IsUnique();
+
+                    b.ToTable("ApiGateways", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGatewayPartner", b =>
+                {
+                    b.Property<int>("ApiGatewayId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PartnerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("ApiGatewayId", "PartnerId", "SubscriptionId");
+
+                    b.HasIndex("PartnerId");
+
+                    b.HasIndex("SubscriptionId");
+
+                    b.ToTable("ApiGatewayPartners", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGateway", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("DataSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DocumentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Endpoint")
+                        .HasMaxLength(500)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("EndpointProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSourceId");
+
+                    b.HasIndex("DocumentId");
+
+                    b.ToTable("BusGateways", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGatewayRoute", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BusGatewayId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("MatchExpression")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("PartnerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BusGatewayId");
+
+                    b.HasIndex("PartnerId");
+
+                    b.HasIndex("SubscriptionId");
+
+                    b.ToTable("BusGatewayRoutes", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.GlobalAdapterValuesSet", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Values")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GlobalAdapterValuesSets", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Notifier", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("HandlerId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("HandlerProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<bool>("RunOnBadResult")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("RunOnFailedResult")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("RunOnSubscriptions")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("RunOnSuccessfulResult")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Notifiers", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.OnHoldXchange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("BadData")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("References")
+                        .HasMaxLength(1024)
+                        .HasColumnType("nvarchar(1024)");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SubscriptionId");
+
+                    b.ToTable("OnHoldXchanges", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Partner", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AdapterProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Partners", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Name = "SYSTEM"
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.ReceiveAttempt", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ErrorMessage")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("ExchangeIds")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("FinishedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("Outcome")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("StartedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SubscriptionId", "StartedOn");
+
+                    b.ToTable("ReceiveAttempts", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.RetryAlertOverride", b =>
+                {
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("AlertHandlerId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AlertHandlerProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<byte>("AlertMode")
+                        .HasColumnType("tinyint");
+
+                    b.HasKey("SubscriptionId", "GroupId");
+
+                    b.ToTable("RetryAlertOverrides", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.RetryGroupUsage", b =>
+                {
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("AttemptsUsed")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ExhaustedNotifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("LastAttemptOn")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("SubscriptionId", "GroupId");
+
+                    b.ToTable("RetryGroupUsages", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.RetryPolicy", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlertHandlerId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AlertHandlerProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Groups")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RetryPolicies", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Setting", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Settings", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Subscription", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("AggregateOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("AggregationForId")
+                        .HasColumnType("int");
+
+                    b.Property<byte>("AggregationTarget")
+                        .HasColumnType("tinyint");
+
+                    b.Property<int?>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ConsecutiveFailures")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomRetryPolicy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("DataSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocumentFilter")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("DocumentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HandlerId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("HandlerProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsRunning")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("LastException")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("MapperId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("MapperProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("MatchExpression")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int?>("PartnerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PausedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ReceiveOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ReceiverId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ReceiverProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ResponseMessageTypeName")
+                        .HasMaxLength(500)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ResponseSubscriptionId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RetryPolicyId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("Temporary")
+                        .HasColumnType("bit");
+
+                    b.Property<byte>("Type")
+                        .HasColumnType("tinyint");
+
+                    b.Property<string>("ValidatorId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ValidatorProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("WorkGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AggregationForId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("DataSourceId");
+
+                    b.HasIndex("DocumentId");
+
+                    b.HasIndex("PartnerId");
+
+                    b.HasIndex("ResponseSubscriptionId");
+
+                    b.HasIndex("RetryPolicyId");
+
+                    b.HasIndex("WorkGroupId");
+
+                    b.ToTable("Subscriptions", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.SubscriptionCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique()
+                        .HasFilter("[Code] IS NOT NULL");
+
+                    b.ToTable("SubscriptionCategory");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.WorkGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("BusMessageName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Options")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WorkGroup");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Xchange", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("CorrelationId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("DocumentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HandlerId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("HandlerProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InputContentType")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("InputHash")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("InputName")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("InputSize")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("ManualRetry")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("MapperId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("MapperProperties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("PartnerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("References")
+                        .HasMaxLength(1024)
+                        .HasColumnType("nvarchar(1024)");
+
+                    b.Property<string>("ResponseMessageTypeName")
+                        .HasMaxLength(500)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ResponseSubscriptionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RetryFor")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("StartedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DocumentId");
+
+                    b.HasIndex("InputHash");
+
+                    b.HasIndex("RetryFor");
+
+                    b.HasIndex("StartedOn");
+
+                    b.HasIndex("SubscriptionId");
+
+                    b.ToTable("Xchanges", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeAggregation", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("AggregatedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("AggregationXchangeId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AggregationXchangeId");
+
+                    b.ToTable("XchangeAggregations", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeDelivery", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("DeliveredOn")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeliveredOn");
+
+                    b.ToTable("XchangeDeliveries", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeNotification", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Exception")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("FinishedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("NotifierId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("NotifierName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Success")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("XchangeId")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("XchangeNotifications", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangePromotedProperties", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Hits")
+                        .HasMaxLength(2000)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(2000)");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PropertiesRaw")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PropertiesRaw");
+
+                    b.ToTable("XchangePromotedProperties", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeResult", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int?>("AttemptNumber")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Exception")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime>("FinishedOn")
+                        .HasColumnType("datetime2");
+
+                    b.Property<bool>("OutputBad")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("OutputContentType")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("OutputHash")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("OutputName")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("OutputSize")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("ResponseBad")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("ResponseContentType")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ResponseHash")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("ResponseName")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("ResponseSize")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ResponseXchangeId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RetryBlockedReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<Guid?>("RetryGroupId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("Success")
+                        .HasColumnType("bit");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RetryGroupId");
+
+                    b.ToTable("XchangeResults", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.RunFlagUpdater+RunningResult", b =>
+                {
+                    b.Property<bool>("IsRunning")
+                        .HasColumnType("bit");
+
+                    b.ToTable((string)null);
+
+                    b.ToView(null, (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.JobExecution", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasColumnName("id");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Context")
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("context");
+
+                    b.Property<long?>("DurationMs")
+                        .HasColumnType("bigint")
+                        .HasColumnName("duration_ms");
+
+                    b.Property<DateTime?>("EndTimeUtc")
+                        .HasColumnType("datetime2")
+                        .HasColumnName("end_time_utc");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("error");
+
+                    b.Property<string>("FireInstanceId")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("fire_instance_id");
+
+                    b.Property<string>("JobGroup")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("job_name");
+
+                    b.Property<string>("JobTypeName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("job_type_name");
+
+                    b.Property<string>("Node")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("node");
+
+                    b.Property<DateTime>("StartTimeUtc")
+                        .HasColumnType("datetime2")
+                        .HasColumnName("start_time_utc");
+
+                    b.Property<bool?>("Success")
+                        .HasColumnType("bit")
+                        .HasColumnName("success");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FireInstanceId")
+                        .IsUnique()
+                        .HasDatabaseName("idx_je_fire_instance_id");
+
+                    b.HasIndex("StartTimeUtc")
+                        .HasDatabaseName("idx_je_start_time");
+
+                    b.HasIndex("Success")
+                        .HasDatabaseName("idx_je_success");
+
+                    b.HasIndex("JobGroup", "JobName", "StartTimeUtc")
+                        .HasDatabaseName("idx_je_group_name_start");
+
+                    b.ToTable("job_executions", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzBlobTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<byte[]>("BlobData")
+                        .HasColumnType("varbinary(max)")
+                        .HasColumnName("blob_data");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("QRTZ_blob_triggers", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzCalendar", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("CalendarName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("calendar_name");
+
+                    b.Property<byte[]>("Calendar")
+                        .IsRequired()
+                        .HasColumnType("varbinary(max)")
+                        .HasColumnName("calendar");
+
+                    b.HasKey("SchedulerName", "CalendarName");
+
+                    b.ToTable("QRTZ_calendars", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzCronTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("CronExpression")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("cron_expression");
+
+                    b.Property<string>("TimeZoneId")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("time_zone_id");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("QRTZ_cron_triggers", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzFiredTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("EntryId")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("entry_id");
+
+                    b.Property<long>("FiredTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("fired_time");
+
+                    b.Property<string>("InstanceName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("instance_name");
+
+                    b.Property<bool>("IsNonConcurrent")
+                        .HasColumnType("bit")
+                        .HasColumnName("is_nonconcurrent");
+
+                    b.Property<string>("JobGroup")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("JobName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("int")
+                        .HasColumnName("priority");
+
+                    b.Property<bool?>("RequestsRecovery")
+                        .HasColumnType("bit")
+                        .HasColumnName("requests_recovery");
+
+                    b.Property<long>("ScheduledTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("sched_time");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("state");
+
+                    b.Property<string>("TriggerGroup")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("TriggerName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_name");
+
+                    b.HasKey("SchedulerName", "EntryId");
+
+                    b.HasIndex("InstanceName")
+                        .HasDatabaseName("idx_QRTZ_ft_trig_inst_name");
+
+                    b.HasIndex("JobGroup")
+                        .HasDatabaseName("idx_QRTZ_ft_job_group");
+
+                    b.HasIndex("JobName")
+                        .HasDatabaseName("idx_QRTZ_ft_job_name");
+
+                    b.HasIndex("RequestsRecovery")
+                        .HasDatabaseName("idx_QRTZ_ft_job_req_recovery");
+
+                    b.HasIndex("TriggerGroup")
+                        .HasDatabaseName("idx_QRTZ_ft_trig_group");
+
+                    b.HasIndex("TriggerName")
+                        .HasDatabaseName("idx_QRTZ_ft_trig_name");
+
+                    b.HasIndex("SchedulerName", "TriggerName", "TriggerGroup")
+                        .HasDatabaseName("idx_QRTZ_ft_trig_nm_gp");
+
+                    b.ToTable("QRTZ_fired_triggers", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzJobDetail", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("JobName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("job_name");
+
+                    b.Property<string>("JobGroup")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("description");
+
+                    b.Property<bool>("IsDurable")
+                        .HasColumnType("bit")
+                        .HasColumnName("is_durable");
+
+                    b.Property<bool>("IsNonConcurrent")
+                        .HasColumnType("bit")
+                        .HasColumnName("is_nonconcurrent");
+
+                    b.Property<bool>("IsUpdateData")
+                        .HasColumnType("bit")
+                        .HasColumnName("is_update_data");
+
+                    b.Property<string>("JobClassName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("job_class_name");
+
+                    b.Property<byte[]>("JobData")
+                        .HasColumnType("varbinary(max)")
+                        .HasColumnName("job_data");
+
+                    b.Property<bool>("RequestsRecovery")
+                        .HasColumnType("bit")
+                        .HasColumnName("requests_recovery");
+
+                    b.HasKey("SchedulerName", "JobName", "JobGroup");
+
+                    b.HasIndex("RequestsRecovery")
+                        .HasDatabaseName("idx_j_req_recovery");
+
+                    b.ToTable("QRTZ_job_details", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzLock", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("LockName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("lock_name");
+
+                    b.HasKey("SchedulerName", "LockName");
+
+                    b.ToTable("QRTZ_locks", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzPausedTriggerGroup", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_group");
+
+                    b.HasKey("SchedulerName", "TriggerGroup");
+
+                    b.ToTable("QRTZ_paused_trigger_grps", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSchedulerState", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("InstanceName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("instance_name");
+
+                    b.Property<long>("CheckInInterval")
+                        .HasColumnType("bigint")
+                        .HasColumnName("checkin_interval");
+
+                    b.Property<long>("LastCheckInTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("last_checkin_time");
+
+                    b.HasKey("SchedulerName", "InstanceName");
+
+                    b.ToTable("QRTZ_scheduler_state", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimplePropertyTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<bool?>("BooleanProperty1")
+                        .HasColumnType("bit")
+                        .HasColumnName("bool_prop_1");
+
+                    b.Property<bool?>("BooleanProperty2")
+                        .HasColumnType("bit")
+                        .HasColumnName("bool_prop_2");
+
+                    b.Property<decimal?>("DecimalProperty1")
+                        .HasColumnType("numeric")
+                        .HasColumnName("dec_prop_1");
+
+                    b.Property<decimal?>("DecimalProperty2")
+                        .HasColumnType("numeric")
+                        .HasColumnName("dec_prop_2");
+
+                    b.Property<int?>("IntegerProperty1")
+                        .HasColumnType("int")
+                        .HasColumnName("int_prop_1");
+
+                    b.Property<int?>("IntegerProperty2")
+                        .HasColumnType("int")
+                        .HasColumnName("int_prop_2");
+
+                    b.Property<long?>("LongProperty1")
+                        .HasColumnType("bigint")
+                        .HasColumnName("long_prop_1");
+
+                    b.Property<long?>("LongProperty2")
+                        .HasColumnType("bigint")
+                        .HasColumnName("long_prop_2");
+
+                    b.Property<string>("StringProperty1")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("str_prop_1");
+
+                    b.Property<string>("StringProperty2")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("str_prop_2");
+
+                    b.Property<string>("StringProperty3")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("str_prop_3");
+
+                    b.Property<string>("TimeZoneId")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("time_zone_id");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("QRTZ_simprop_triggers", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimpleTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<long>("RepeatCount")
+                        .HasColumnType("bigint")
+                        .HasColumnName("repeat_count");
+
+                    b.Property<long>("RepeatInterval")
+                        .HasColumnType("bigint")
+                        .HasColumnName("repeat_interval");
+
+                    b.Property<long>("TimesTriggered")
+                        .HasColumnType("bigint")
+                        .HasColumnName("times_triggered");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("QRTZ_simple_triggers", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("CalendarName")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("calendar_name");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("description");
+
+                    b.Property<long?>("EndTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("end_time");
+
+                    b.Property<byte[]>("JobData")
+                        .HasColumnType("varbinary(max)")
+                        .HasColumnName("job_data");
+
+                    b.Property<string>("JobGroup")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("job_name");
+
+                    b.Property<int?>("MisfireInstruction")
+                        .HasColumnType("int")
+                        .HasColumnName("misfire_instr");
+
+                    b.Property<long?>("NextFireTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("next_fire_time");
+
+                    b.Property<long?>("PreviousFireTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("prev_fire_time");
+
+                    b.Property<int?>("Priority")
+                        .HasColumnType("int")
+                        .HasColumnName("priority");
+
+                    b.Property<long>("StartTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("start_time");
+
+                    b.Property<string>("TriggerState")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_state");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("trigger_type");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.HasIndex("NextFireTime")
+                        .HasDatabaseName("idx_t_next_fire_time");
+
+                    b.HasIndex("TriggerState")
+                        .HasDatabaseName("idx_t_state");
+
+                    b.HasIndex("NextFireTime", "TriggerState")
+                        .HasDatabaseName("idx_t_nft_st");
+
+                    b.HasIndex("SchedulerName", "JobName", "JobGroup");
+
+                    b.ToTable("QRTZ_triggers", "dbo");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.AccountRoleLink", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Accounts.Account", null)
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.Accounts.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.RefreshToken", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Accounts.Account", null)
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.DataSourceStatement", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", "DataSource")
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.WorkGroup", null)
+                        .WithMany()
+                        .HasForeignKey("WorkGroupId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DataSource");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.InboundMessage", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", null)
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGatewayPartner", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Gateway.ApiGateway", "ApiGateway")
+                        .WithMany("Partners")
+                        .HasForeignKey("ApiGatewayId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.Partner", "Partner")
+                        .WithMany()
+                        .HasForeignKey("PartnerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.Subscription", "Subscription")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ApiGateway");
+
+                    b.Navigation("Partner");
+
+                    b.Navigation("Subscription");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGateway", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", "DataSource")
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("SW.Bitween.Domain.Document", null)
+                        .WithMany()
+                        .HasForeignKey("DocumentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("DataSource");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGatewayRoute", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Gateway.BusGateway", "BusGateway")
+                        .WithMany("Routes")
+                        .HasForeignKey("BusGatewayId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.Partner", "Partner")
+                        .WithMany()
+                        .HasForeignKey("PartnerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("SW.Bitween.Domain.Subscription", "Subscription")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BusGateway");
+
+                    b.Navigation("Partner");
+
+                    b.Navigation("Subscription");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Partner", b =>
+                {
+                    b.OwnsMany("SW.Bitween.Domain.ApiCredential", "ApiCredentials", b1 =>
+                        {
+                            b1.Property<int>("PartnerId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int");
+
+                            SqlServerPropertyBuilderExtensions.UseIdentityColumn(b1.Property<int>("Id"));
+
+                            b1.Property<string>("Key")
+                                .IsRequired()
+                                .HasMaxLength(500)
+                                .IsUnicode(false)
+                                .HasColumnType("varchar(500)");
+
+                            b1.Property<string>("Name")
+                                .IsRequired()
+                                .HasMaxLength(500)
+                                .HasColumnType("nvarchar(500)");
+
+                            b1.HasKey("PartnerId", "Id");
+
+                            b1.HasIndex("Key")
+                                .IsUnique();
+
+                            b1.ToTable("PartnerApiCredentials", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PartnerId");
+
+                            b1.HasData(
+                                new
+                                {
+                                    PartnerId = 1,
+                                    Id = 1,
+                                    Key = "7facc758283844b49cc4ffd26a75b1de",
+                                    Name = "default"
+                                });
+                        });
+
+                    b.Navigation("ApiCredentials");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Subscription", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Subscription", null)
+                        .WithMany()
+                        .HasForeignKey("AggregationForId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("FK_Subscriptions_AggFor");
+
+                    b.HasOne("SW.Bitween.Domain.SubscriptionCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId");
+
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", null)
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("SW.Bitween.Domain.Document", null)
+                        .WithMany()
+                        .HasForeignKey("DocumentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.Partner", null)
+                        .WithMany("Subscriptions")
+                        .HasForeignKey("PartnerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("SW.Bitween.Domain.Subscription", null)
+                        .WithMany()
+                        .HasForeignKey("ResponseSubscriptionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("FK_Subscriptions_RespSub");
+
+                    b.HasOne("SW.Bitween.Domain.RetryPolicy", "RetryPolicy")
+                        .WithMany()
+                        .HasForeignKey("RetryPolicyId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("SW.Bitween.Domain.WorkGroup", "WorkGroup")
+                        .WithMany()
+                        .HasForeignKey("WorkGroupId");
+
+                    b.OwnsMany("SW.Bitween.Domain.Schedule", "Schedules", b1 =>
+                        {
+                            b1.Property<int>("SubscriptionId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int");
+
+                            SqlServerPropertyBuilderExtensions.UseIdentityColumn(b1.Property<int>("Id"));
+
+                            b1.Property<bool>("Backwards")
+                                .HasColumnType("bit");
+
+                            b1.Property<long>("On")
+                                .HasColumnType("bigint");
+
+                            b1.Property<byte>("Recurrence")
+                                .HasColumnType("tinyint");
+
+                            b1.HasKey("SubscriptionId", "Id");
+
+                            b1.ToTable("SubscriptionSchedules", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("SubscriptionId");
+                        });
+
+                    b.Navigation("Category");
+
+                    b.Navigation("RetryPolicy");
+
+                    b.Navigation("Schedules");
+
+                    b.Navigation("WorkGroup");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Xchange", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Document", null)
+                        .WithMany()
+                        .HasForeignKey("DocumentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeAggregation", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangeAggregation", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeDelivery", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangeDelivery", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangePromotedProperties", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangePromotedProperties", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeResult", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangeResult", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzBlobTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("BlobTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzCronTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("CronTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimplePropertyTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("SimplePropertyTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimpleTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("SimpleTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzJobDetail", "JobDetail")
+                        .WithMany("Triggers")
+                        .HasForeignKey("SchedulerName", "JobName", "JobGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JobDetail");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGateway", b =>
+                {
+                    b.Navigation("Partners");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGateway", b =>
+                {
+                    b.Navigation("Routes");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Partner", b =>
+                {
+                    b.Navigation("Subscriptions");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzJobDetail", b =>
+                {
+                    b.Navigation("Triggers");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzTrigger", b =>
+                {
+                    b.Navigation("BlobTriggers");
+
+                    b.Navigation("CronTriggers");
+
+                    b.Navigation("SimplePropertyTriggers");
+
+                    b.Navigation("SimpleTriggers");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/SW.Bitween.MsSql/Migrations/20260915090333_AddMustChangePassword.cs b/SW.Bitween.MsSql/Migrations/20260915090333_AddMustChangePassword.cs
new file mode 100644
index 00000000..c01c418c
--- /dev/null
+++ b/SW.Bitween.MsSql/Migrations/20260915090333_AddMustChangePassword.cs
@@ -0,0 +1,46 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace SW.Bitween.MsSql.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddMustChangePassword : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "MustChangePassword",
+                table: "Accounts",
+                type: "bit",
+                nullable: false,
+                defaultValue: false);
+
+            // Only where the password is still the one we ship.
+            //
+            // EF scaffolded a plain UpdateData here, because as far as the model is concerned the
+            // seeded row simply gained a column value. That would have demanded a new password from
+            // every installation on the next deploy, including the ones that chose theirs years ago
+            // — a forced interruption for people who had already done the right thing.
+            //
+            // Matching on the stored hash narrows it to the installations the flag is actually for:
+            // those still signing in with the password published in our public repository. On
+            // anything else this updates no rows at all.
+            migrationBuilder.Sql(
+                """
+                UPDATE [Accounts]
+                SET [MustChangePassword] = 1
+                WHERE [Id] = 9999 AND [Password] = '$SWHASH$V1$10000$VQCi48eitH4Ml5juvBMOFZrMdQwBbhuIQVXe6RR7qJdDF2bJ';
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "MustChangePassword",
+                table: "Accounts");
+        }
+    }
+}
diff --git a/SW.Bitween.MsSql/Migrations/BitweenDbContextModelSnapshot.cs b/SW.Bitween.MsSql/Migrations/BitweenDbContextModelSnapshot.cs
index 51647348..80c6bfb1 100644
--- a/SW.Bitween.MsSql/Migrations/BitweenDbContextModelSnapshot.cs
+++ b/SW.Bitween.MsSql/Migrations/BitweenDbContextModelSnapshot.cs
@@ -72,6 +72,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<DateTime?>("ModifiedOn")
                         .HasColumnType("datetime2");
 
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("bit");
+
                     b.Property<string>("Password")
                         .HasMaxLength(500)
                         .IsUnicode(false)
@@ -100,6 +103,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                             EmailProvider = (byte)0,
                             FailedLoginCount = 0,
                             LoginMethods = (byte)2,
+                            MustChangePassword = true,
                             Password = "$SWHASH$V1$10000$VQCi48eitH4Ml5juvBMOFZrMdQwBbhuIQVXe6RR7qJdDF2bJ",
                             Role = 0
                         });
diff --git a/SW.Bitween.MySql/Migrations/20260915090329_AddMustChangePassword.Designer.cs b/SW.Bitween.MySql/Migrations/20260915090329_AddMustChangePassword.Designer.cs
new file mode 100644
index 00000000..c5c60260
--- /dev/null
+++ b/SW.Bitween.MySql/Migrations/20260915090329_AddMustChangePassword.Designer.cs
@@ -0,0 +1,2388 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using SW.Bitween.MySql;
+
+#nullable disable
+
+namespace SW.Bitween.MySql.Migrations
+{
+    [DbContext(typeof(BitweenDbContext))]
+    [Migration("20260915090329_AddMustChangePassword")]
+    partial class AddMustChangePassword
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.19")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            MySqlModelBuilderExtensions.AutoIncrementColumns(modelBuilder);
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.Account", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("Disabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<byte>("EmailProvider")
+                        .HasColumnType("tinyint unsigned");
+
+                    b.Property<int>("FailedLoginCount")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LockoutEnd")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<byte>("LoginMethods")
+                        .HasColumnType("tinyint unsigned");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Password")
+                        .HasMaxLength(500)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Email")
+                        .IsUnique();
+
+                    b.ToTable("Accounts", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 9999,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Deleted = false,
+                            Disabled = false,
+                            DisplayName = "Admin",
+                            Email = "admin@Bitween.systems",
+                            EmailProvider = (byte)0,
+                            FailedLoginCount = 0,
+                            LoginMethods = (byte)2,
+                            MustChangePassword = true,
+                            Password = "$SWHASH$V1$10000$VQCi48eitH4Ml5juvBMOFZrMdQwBbhuIQVXe6RR7qJdDF2bJ",
+                            Role = 0
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.AccountRoleLink", b =>
+                {
+                    b.Property<int>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("int");
+
+                    b.HasKey("AccountId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AccountRoles", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.RefreshToken", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int>("AccountId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<byte>("LoginMethod")
+                        .HasColumnType("tinyint unsigned");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("RefreshTokens", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Permissions")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Roles", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Description = "Full access to everything, including members, roles and settings.",
+                            IsSystem = true,
+                            Name = "Administrator",
+                            Permissions = "[]"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Description = "Runs and configures integrations. Can't manage members, roles or settings.",
+                            IsSystem = true,
+                            Name = "Member",
+                            Permissions = "[]"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Description = "Read-only access to integrations, exchanges and configuration.",
+                            IsSystem = true,
+                            Name = "Viewer",
+                            Permissions = "[]"
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.AuditEntry", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(32)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(32)");
+
+                    b.Property<string>("Changes")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("CorrelationId")
+                        .IsRequired()
+                        .HasMaxLength(36)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(36)");
+
+                    b.Property<string>("EntityKey")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("EntityName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("OccurredOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("int");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(10)");
+
+                    b.Property<string>("UserId")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CorrelationId");
+
+                    b.HasIndex("OccurredOn");
+
+                    b.HasIndex("EntityName", "EntityKey", "OccurredOn");
+
+                    b.ToTable("AuditEntries", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Cluster.ClusterLease", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("AcquiredOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("OwnerNode")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<long>("Term")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ClusterLeases", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.AdapterState", b =>
+                {
+                    b.Property<string>("AdapterId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("InstanceKey")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Value")
+                        .HasMaxLength(8000)
+                        .HasColumnType("varchar(8000)");
+
+                    b.HasKey("AdapterId", "InstanceKey", "Name");
+
+                    b.ToTable("AdapterStates", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.DataSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AdapterId")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ConsecutiveFailures")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CpuLimitSamples")
+                        .HasColumnType("int");
+
+                    b.Property<double>("CpuPercentLimit")
+                        .HasColumnType("double");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("DeduplicationWindowDays")
+                        .HasColumnType("int");
+
+                    b.Property<int>("HardMemoryLimitMb")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("LastException")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("LastHeartbeatOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("LastKnownState")
+                        .HasMaxLength(100)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("OwnedByNode")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("Placement")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("SecretProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("SoftMemoryLimitMb")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("DataSources", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.DataSourceStatement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("CursorColumn")
+                        .HasMaxLength(128)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(128)");
+
+                    b.Property<int>("DataSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("varchar(1000)");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("KeyColumn")
+                        .HasMaxLength(128)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(128)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Sql")
+                        .IsRequired()
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("WorkGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorkGroupId");
+
+                    b.HasIndex("DataSourceId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("DataSourceStatements", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.InboundMessage", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(400)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(400)");
+
+                    b.Property<int>("DataSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("SeenOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("XchangeId")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSourceId");
+
+                    b.HasIndex("SeenOn");
+
+                    b.ToTable("InboundMessages", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DelayedRetry", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("On")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("On");
+
+                    b.ToTable("DelayedRetries", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Document", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("BusEnabled")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("BusMessageTypeName")
+                        .HasMaxLength(500)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("Code")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<bool?>("DisregardsUnfilteredMessages")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("DocumentFormat")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DuplicateInterval")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("PromotedProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("RetiredOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BusMessageTypeName")
+                        .IsUnique();
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Documents", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 10001,
+                            BusEnabled = false,
+                            DocumentFormat = 0,
+                            DuplicateInterval = 0,
+                            Name = "Aggregation Document",
+                            PromotedProperties = "{}"
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGateway", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("UrlName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UrlName")
+                        .IsUnique();
+
+                    b.ToTable("ApiGateways", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGatewayPartner", b =>
+                {
+                    b.Property<int>("ApiGatewayId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PartnerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("ApiGatewayId", "PartnerId", "SubscriptionId");
+
+                    b.HasIndex("PartnerId");
+
+                    b.HasIndex("SubscriptionId");
+
+                    b.ToTable("ApiGatewayPartners", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGateway", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("DataSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("DocumentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Endpoint")
+                        .HasMaxLength(500)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<string>("EndpointProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataSourceId");
+
+                    b.HasIndex("DocumentId");
+
+                    b.ToTable("BusGateways", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGatewayRoute", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BusGatewayId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("MatchExpression")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("PartnerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BusGatewayId");
+
+                    b.HasIndex("PartnerId");
+
+                    b.HasIndex("SubscriptionId");
+
+                    b.ToTable("BusGatewayRoutes", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.GlobalAdapterValuesSet", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Values")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GlobalAdapterValuesSets", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Notifier", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("HandlerId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("HandlerProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<bool>("RunOnBadResult")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("RunOnFailedResult")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("RunOnSubscriptions")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("RunOnSuccessfulResult")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Notifiers", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.OnHoldXchange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("BadData")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("References")
+                        .HasMaxLength(1024)
+                        .HasColumnType("varchar(1024)");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SubscriptionId");
+
+                    b.ToTable("OnHoldXchanges", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Partner", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AdapterProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Partners", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Name = "SYSTEM"
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.ReceiveAttempt", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ErrorMessage")
+                        .HasMaxLength(4000)
+                        .HasColumnType("varchar(4000)");
+
+                    b.Property<string>("ExchangeIds")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("FinishedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Outcome")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("StartedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SubscriptionId", "StartedOn");
+
+                    b.ToTable("ReceiveAttempts", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.RetryAlertOverride", b =>
+                {
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<string>("AlertHandlerId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AlertHandlerProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<byte>("AlertMode")
+                        .HasColumnType("tinyint unsigned");
+
+                    b.HasKey("SubscriptionId", "GroupId");
+
+                    b.ToTable("RetryAlertOverrides", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.RetryGroupUsage", b =>
+                {
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<int>("AttemptsUsed")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("ExhaustedNotifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("LastAttemptOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("SubscriptionId", "GroupId");
+
+                    b.ToTable("RetryGroupUsages", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.RetryPolicy", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlertHandlerId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("AlertHandlerProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Groups")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RetryPolicies", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Setting", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Settings", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Subscription", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("AggregateOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("AggregationForId")
+                        .HasColumnType("int");
+
+                    b.Property<byte>("AggregationTarget")
+                        .HasColumnType("tinyint unsigned");
+
+                    b.Property<int?>("CategoryId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ConsecutiveFailures")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomRetryPolicy")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("DataSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DocumentFilter")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("DocumentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HandlerId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("HandlerProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsRunning")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("LastException")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("MapperId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("MapperProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("MatchExpression")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<int?>("PartnerId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("PausedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("ReceiveOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("ReceiverId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ReceiverProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ResponseMessageTypeName")
+                        .HasMaxLength(500)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ResponseSubscriptionId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("RetryPolicyId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("Temporary")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<byte>("Type")
+                        .HasColumnType("tinyint unsigned");
+
+                    b.Property<string>("ValidatorId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ValidatorProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("WorkGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AggregationForId");
+
+                    b.HasIndex("CategoryId");
+
+                    b.HasIndex("DataSourceId");
+
+                    b.HasIndex("DocumentId");
+
+                    b.HasIndex("PartnerId");
+
+                    b.HasIndex("ResponseSubscriptionId");
+
+                    b.HasIndex("RetryPolicyId");
+
+                    b.HasIndex("WorkGroupId");
+
+                    b.ToTable("Subscriptions", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.SubscriptionCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code")
+                        .IsUnique();
+
+                    b.ToTable("SubscriptionCategory");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.WorkGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("BusMessageName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Options")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WorkGroup");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Xchange", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("CorrelationId")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("DocumentId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HandlerId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("HandlerProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("InputContentType")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("InputHash")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("InputName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("InputSize")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("ManualRetry")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("MapperId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("MapperProperties")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("PartnerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("References")
+                        .HasMaxLength(1024)
+                        .HasColumnType("varchar(1024)");
+
+                    b.Property<string>("ResponseMessageTypeName")
+                        .HasMaxLength(500)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<int?>("ResponseSubscriptionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RetryFor")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("StartedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SubscriptionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DocumentId");
+
+                    b.HasIndex("InputHash");
+
+                    b.HasIndex("RetryFor");
+
+                    b.HasIndex("StartedOn");
+
+                    b.HasIndex("SubscriptionId");
+
+                    b.ToTable("Xchanges", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeAggregation", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("AggregatedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("AggregationXchangeId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AggregationXchangeId");
+
+                    b.ToTable("XchangeAggregations", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeDelivery", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<DateTime>("DeliveredOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeliveredOn");
+
+                    b.ToTable("XchangeDeliveries", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeNotification", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Exception")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("FinishedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("NotifierId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("NotifierName")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("Success")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("XchangeId")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("XchangeNotifications", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangePromotedProperties", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("Hits")
+                        .HasMaxLength(2000)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(2000)");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PropertiesRaw")
+                        .HasColumnType("varchar(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PropertiesRaw");
+
+                    b.ToTable("XchangePromotedProperties", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeResult", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<int?>("AttemptNumber")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Exception")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("FinishedOn")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("OutputBad")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("OutputContentType")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("OutputHash")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("OutputName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("OutputSize")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("ResponseBad")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("ResponseContentType")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<string>("ResponseHash")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(50)");
+
+                    b.Property<string>("ResponseName")
+                        .HasMaxLength(200)
+                        .HasColumnType("varchar(200)");
+
+                    b.Property<int>("ResponseSize")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ResponseXchangeId")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("RetryBlockedReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("varchar(500)");
+
+                    b.Property<Guid?>("RetryGroupId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<bool>("Success")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RetryGroupId");
+
+                    b.ToTable("XchangeResults", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.RunFlagUpdater+RunningResult", b =>
+                {
+                    b.Property<bool>("IsRunning")
+                        .HasColumnType("tinyint(1)");
+
+                    b.ToTable((string)null);
+
+                    b.ToView(null, (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.JobExecution", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasColumnName("id");
+
+                    MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Context")
+                        .HasColumnType("longtext")
+                        .HasColumnName("context");
+
+                    b.Property<long?>("DurationMs")
+                        .HasColumnType("bigint")
+                        .HasColumnName("duration_ms");
+
+                    b.Property<DateTime?>("EndTimeUtc")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("end_time_utc");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("longtext")
+                        .HasColumnName("error");
+
+                    b.Property<string>("FireInstanceId")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("fire_instance_id");
+
+                    b.Property<string>("JobGroup")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("job_name");
+
+                    b.Property<string>("JobTypeName")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("job_type_name");
+
+                    b.Property<string>("Node")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("node");
+
+                    b.Property<DateTime>("StartTimeUtc")
+                        .HasColumnType("datetime(6)")
+                        .HasColumnName("start_time_utc");
+
+                    b.Property<bool?>("Success")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("success");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FireInstanceId")
+                        .IsUnique()
+                        .HasDatabaseName("idx_je_fire_instance_id");
+
+                    b.HasIndex("StartTimeUtc")
+                        .HasDatabaseName("idx_je_start_time");
+
+                    b.HasIndex("Success")
+                        .HasDatabaseName("idx_je_success");
+
+                    b.HasIndex("JobGroup", "JobName", "StartTimeUtc")
+                        .HasDatabaseName("idx_je_group_name_start");
+
+                    b.ToTable("job_executions", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzBlobTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<byte[]>("BlobData")
+                        .HasColumnType("longblob")
+                        .HasColumnName("blob_data");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("QRTZ_blob_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzCalendar", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("CalendarName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("calendar_name");
+
+                    b.Property<byte[]>("Calendar")
+                        .IsRequired()
+                        .HasColumnType("longblob")
+                        .HasColumnName("calendar");
+
+                    b.HasKey("SchedulerName", "CalendarName");
+
+                    b.ToTable("QRTZ_calendars", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzCronTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("CronExpression")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("cron_expression");
+
+                    b.Property<string>("TimeZoneId")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("time_zone_id");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("QRTZ_cron_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzFiredTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("EntryId")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("entry_id");
+
+                    b.Property<long>("FiredTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("fired_time");
+
+                    b.Property<string>("InstanceName")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("instance_name");
+
+                    b.Property<bool>("IsNonConcurrent")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("is_nonconcurrent");
+
+                    b.Property<string>("JobGroup")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("JobName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("int")
+                        .HasColumnName("priority");
+
+                    b.Property<bool?>("RequestsRecovery")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("requests_recovery");
+
+                    b.Property<long>("ScheduledTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("sched_time");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("state");
+
+                    b.Property<string>("TriggerGroup")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("TriggerName")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_name");
+
+                    b.HasKey("SchedulerName", "EntryId");
+
+                    b.HasIndex("InstanceName")
+                        .HasDatabaseName("idx_QRTZ_ft_trig_inst_name");
+
+                    b.HasIndex("JobGroup")
+                        .HasDatabaseName("idx_QRTZ_ft_job_group");
+
+                    b.HasIndex("JobName")
+                        .HasDatabaseName("idx_QRTZ_ft_job_name");
+
+                    b.HasIndex("RequestsRecovery")
+                        .HasDatabaseName("idx_QRTZ_ft_job_req_recovery");
+
+                    b.HasIndex("TriggerGroup")
+                        .HasDatabaseName("idx_QRTZ_ft_trig_group");
+
+                    b.HasIndex("TriggerName")
+                        .HasDatabaseName("idx_QRTZ_ft_trig_name");
+
+                    b.HasIndex("SchedulerName", "TriggerName", "TriggerGroup")
+                        .HasDatabaseName("idx_QRTZ_ft_trig_nm_gp");
+
+                    b.ToTable("QRTZ_fired_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzJobDetail", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("JobName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("job_name");
+
+                    b.Property<string>("JobGroup")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("description");
+
+                    b.Property<bool>("IsDurable")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("is_durable");
+
+                    b.Property<bool>("IsNonConcurrent")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("is_nonconcurrent");
+
+                    b.Property<bool>("IsUpdateData")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("is_update_data");
+
+                    b.Property<string>("JobClassName")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("job_class_name");
+
+                    b.Property<byte[]>("JobData")
+                        .HasColumnType("longblob")
+                        .HasColumnName("job_data");
+
+                    b.Property<bool>("RequestsRecovery")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("requests_recovery");
+
+                    b.HasKey("SchedulerName", "JobName", "JobGroup");
+
+                    b.HasIndex("RequestsRecovery")
+                        .HasDatabaseName("idx_j_req_recovery");
+
+                    b.ToTable("QRTZ_job_details", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzLock", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("LockName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("lock_name");
+
+                    b.HasKey("SchedulerName", "LockName");
+
+                    b.ToTable("QRTZ_locks", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzPausedTriggerGroup", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_group");
+
+                    b.HasKey("SchedulerName", "TriggerGroup");
+
+                    b.ToTable("QRTZ_paused_trigger_grps", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSchedulerState", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("InstanceName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("instance_name");
+
+                    b.Property<long>("CheckInInterval")
+                        .HasColumnType("bigint")
+                        .HasColumnName("checkin_interval");
+
+                    b.Property<long>("LastCheckInTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("last_checkin_time");
+
+                    b.HasKey("SchedulerName", "InstanceName");
+
+                    b.ToTable("QRTZ_scheduler_state", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimplePropertyTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<bool?>("BooleanProperty1")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("bool_prop_1");
+
+                    b.Property<bool?>("BooleanProperty2")
+                        .HasColumnType("tinyint(1)")
+                        .HasColumnName("bool_prop_2");
+
+                    b.Property<decimal?>("DecimalProperty1")
+                        .HasColumnType("numeric")
+                        .HasColumnName("dec_prop_1");
+
+                    b.Property<decimal?>("DecimalProperty2")
+                        .HasColumnType("numeric")
+                        .HasColumnName("dec_prop_2");
+
+                    b.Property<int?>("IntegerProperty1")
+                        .HasColumnType("int")
+                        .HasColumnName("int_prop_1");
+
+                    b.Property<int?>("IntegerProperty2")
+                        .HasColumnType("int")
+                        .HasColumnName("int_prop_2");
+
+                    b.Property<long?>("LongProperty1")
+                        .HasColumnType("bigint")
+                        .HasColumnName("long_prop_1");
+
+                    b.Property<long?>("LongProperty2")
+                        .HasColumnType("bigint")
+                        .HasColumnName("long_prop_2");
+
+                    b.Property<string>("StringProperty1")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("str_prop_1");
+
+                    b.Property<string>("StringProperty2")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("str_prop_2");
+
+                    b.Property<string>("StringProperty3")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("str_prop_3");
+
+                    b.Property<string>("TimeZoneId")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("time_zone_id");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("QRTZ_simprop_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimpleTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<long>("RepeatCount")
+                        .HasColumnType("bigint")
+                        .HasColumnName("repeat_count");
+
+                    b.Property<long>("RepeatInterval")
+                        .HasColumnType("bigint")
+                        .HasColumnName("repeat_interval");
+
+                    b.Property<long>("TimesTriggered")
+                        .HasColumnType("bigint")
+                        .HasColumnName("times_triggered");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("QRTZ_simple_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("CalendarName")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("calendar_name");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("description");
+
+                    b.Property<long?>("EndTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("end_time");
+
+                    b.Property<byte[]>("JobData")
+                        .HasColumnType("longblob")
+                        .HasColumnName("job_data");
+
+                    b.Property<string>("JobGroup")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("job_name");
+
+                    b.Property<int?>("MisfireInstruction")
+                        .HasColumnType("int")
+                        .HasColumnName("misfire_instr");
+
+                    b.Property<long?>("NextFireTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("next_fire_time");
+
+                    b.Property<long?>("PreviousFireTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("prev_fire_time");
+
+                    b.Property<int?>("Priority")
+                        .HasColumnType("int")
+                        .HasColumnName("priority");
+
+                    b.Property<long>("StartTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("start_time");
+
+                    b.Property<string>("TriggerState")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_state");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasColumnType("varchar(200)")
+                        .HasColumnName("trigger_type");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.HasIndex("NextFireTime")
+                        .HasDatabaseName("idx_t_next_fire_time");
+
+                    b.HasIndex("TriggerState")
+                        .HasDatabaseName("idx_t_state");
+
+                    b.HasIndex("NextFireTime", "TriggerState")
+                        .HasDatabaseName("idx_t_nft_st");
+
+                    b.HasIndex("SchedulerName", "JobName", "JobGroup");
+
+                    b.ToTable("QRTZ_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.AccountRoleLink", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Accounts.Account", null)
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.Accounts.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.RefreshToken", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Accounts.Account", null)
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.DataSourceStatement", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", "DataSource")
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.WorkGroup", null)
+                        .WithMany()
+                        .HasForeignKey("WorkGroupId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("DataSource");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.InboundMessage", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", null)
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGatewayPartner", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Gateway.ApiGateway", "ApiGateway")
+                        .WithMany("Partners")
+                        .HasForeignKey("ApiGatewayId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.Partner", "Partner")
+                        .WithMany()
+                        .HasForeignKey("PartnerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.Subscription", "Subscription")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("ApiGateway");
+
+                    b.Navigation("Partner");
+
+                    b.Navigation("Subscription");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGateway", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", "DataSource")
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("SW.Bitween.Domain.Document", null)
+                        .WithMany()
+                        .HasForeignKey("DocumentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("DataSource");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGatewayRoute", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Gateway.BusGateway", "BusGateway")
+                        .WithMany("Routes")
+                        .HasForeignKey("BusGatewayId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.Partner", "Partner")
+                        .WithMany()
+                        .HasForeignKey("PartnerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("SW.Bitween.Domain.Subscription", "Subscription")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("BusGateway");
+
+                    b.Navigation("Partner");
+
+                    b.Navigation("Subscription");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Partner", b =>
+                {
+                    b.OwnsMany("SW.Bitween.Domain.ApiCredential", "ApiCredentials", b1 =>
+                        {
+                            b1.Property<int>("PartnerId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int");
+
+                            MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b1.Property<int>("Id"));
+
+                            b1.Property<string>("Key")
+                                .IsRequired()
+                                .HasMaxLength(500)
+                                .IsUnicode(false)
+                                .HasColumnType("varchar(500)");
+
+                            b1.Property<string>("Name")
+                                .IsRequired()
+                                .HasMaxLength(500)
+                                .HasColumnType("varchar(500)");
+
+                            b1.HasKey("PartnerId", "Id");
+
+                            b1.HasIndex("Key")
+                                .IsUnique();
+
+                            b1.ToTable("PartnerApiCredentials", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PartnerId");
+
+                            b1.HasData(
+                                new
+                                {
+                                    PartnerId = 1,
+                                    Id = 1,
+                                    Key = "7facc758283844b49cc4ffd26a75b1de",
+                                    Name = "default"
+                                });
+                        });
+
+                    b.Navigation("ApiCredentials");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Subscription", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Subscription", null)
+                        .WithMany()
+                        .HasForeignKey("AggregationForId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("FK_Subscriptions_AggFor");
+
+                    b.HasOne("SW.Bitween.Domain.SubscriptionCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId");
+
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", null)
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("SW.Bitween.Domain.Document", null)
+                        .WithMany()
+                        .HasForeignKey("DocumentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("SW.Bitween.Domain.Partner", null)
+                        .WithMany("Subscriptions")
+                        .HasForeignKey("PartnerId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("SW.Bitween.Domain.Subscription", null)
+                        .WithMany()
+                        .HasForeignKey("ResponseSubscriptionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("FK_Subscriptions_RespSub");
+
+                    b.HasOne("SW.Bitween.Domain.RetryPolicy", "RetryPolicy")
+                        .WithMany()
+                        .HasForeignKey("RetryPolicyId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("SW.Bitween.Domain.WorkGroup", "WorkGroup")
+                        .WithMany()
+                        .HasForeignKey("WorkGroupId");
+
+                    b.OwnsMany("SW.Bitween.Domain.Schedule", "Schedules", b1 =>
+                        {
+                            b1.Property<int>("SubscriptionId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("int");
+
+                            MySqlPropertyBuilderExtensions.UseMySqlIdentityColumn(b1.Property<int>("Id"));
+
+                            b1.Property<bool>("Backwards")
+                                .HasColumnType("tinyint(1)");
+
+                            b1.Property<long>("On")
+                                .HasColumnType("bigint");
+
+                            b1.Property<byte>("Recurrence")
+                                .HasColumnType("tinyint unsigned");
+
+                            b1.HasKey("SubscriptionId", "Id");
+
+                            b1.ToTable("SubscriptionSchedules", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("SubscriptionId");
+                        });
+
+                    b.Navigation("Category");
+
+                    b.Navigation("RetryPolicy");
+
+                    b.Navigation("Schedules");
+
+                    b.Navigation("WorkGroup");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Xchange", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Document", null)
+                        .WithMany()
+                        .HasForeignKey("DocumentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeAggregation", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangeAggregation", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeDelivery", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangeDelivery", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangePromotedProperties", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangePromotedProperties", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeResult", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangeResult", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzBlobTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("BlobTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzCronTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("CronTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimplePropertyTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("SimplePropertyTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimpleTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("SimpleTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzJobDetail", "JobDetail")
+                        .WithMany("Triggers")
+                        .HasForeignKey("SchedulerName", "JobName", "JobGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JobDetail");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGateway", b =>
+                {
+                    b.Navigation("Partners");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGateway", b =>
+                {
+                    b.Navigation("Routes");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Partner", b =>
+                {
+                    b.Navigation("Subscriptions");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzJobDetail", b =>
+                {
+                    b.Navigation("Triggers");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzTrigger", b =>
+                {
+                    b.Navigation("BlobTriggers");
+
+                    b.Navigation("CronTriggers");
+
+                    b.Navigation("SimplePropertyTriggers");
+
+                    b.Navigation("SimpleTriggers");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/SW.Bitween.MySql/Migrations/20260915090329_AddMustChangePassword.cs b/SW.Bitween.MySql/Migrations/20260915090329_AddMustChangePassword.cs
new file mode 100644
index 00000000..a8e7326a
--- /dev/null
+++ b/SW.Bitween.MySql/Migrations/20260915090329_AddMustChangePassword.cs
@@ -0,0 +1,46 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace SW.Bitween.MySql.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddMustChangePassword : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "MustChangePassword",
+                table: "Accounts",
+                type: "tinyint(1)",
+                nullable: false,
+                defaultValue: false);
+
+            // Only where the password is still the one we ship.
+            //
+            // EF scaffolded a plain UpdateData here, because as far as the model is concerned the
+            // seeded row simply gained a column value. That would have demanded a new password from
+            // every installation on the next deploy, including the ones that chose theirs years ago
+            // — a forced interruption for people who had already done the right thing.
+            //
+            // Matching on the stored hash narrows it to the installations the flag is actually for:
+            // those still signing in with the password published in our public repository. On
+            // anything else this updates no rows at all.
+            migrationBuilder.Sql(
+                """
+                UPDATE `Accounts`
+                SET `MustChangePassword` = 1
+                WHERE `Id` = 9999 AND `Password` = '$SWHASH$V1$10000$VQCi48eitH4Ml5juvBMOFZrMdQwBbhuIQVXe6RR7qJdDF2bJ';
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "MustChangePassword",
+                table: "Accounts");
+        }
+    }
+}
diff --git a/SW.Bitween.MySql/Migrations/BitweenDbContextModelSnapshot.cs b/SW.Bitween.MySql/Migrations/BitweenDbContextModelSnapshot.cs
index 9ecc079c..a0c8bb8a 100644
--- a/SW.Bitween.MySql/Migrations/BitweenDbContextModelSnapshot.cs
+++ b/SW.Bitween.MySql/Migrations/BitweenDbContextModelSnapshot.cs
@@ -70,6 +70,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<DateTime?>("ModifiedOn")
                         .HasColumnType("datetime(6)");
 
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("tinyint(1)");
+
                     b.Property<string>("Password")
                         .HasMaxLength(500)
                         .IsUnicode(false)
@@ -97,6 +100,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                             EmailProvider = (byte)0,
                             FailedLoginCount = 0,
                             LoginMethods = (byte)2,
+                            MustChangePassword = true,
                             Password = "$SWHASH$V1$10000$VQCi48eitH4Ml5juvBMOFZrMdQwBbhuIQVXe6RR7qJdDF2bJ",
                             Role = 0
                         });
diff --git a/SW.Bitween.PgSql/BitweenDbContext.cs b/SW.Bitween.PgSql/BitweenDbContext.cs
index bbb8b2e6..3ec251f0 100644
--- a/SW.Bitween.PgSql/BitweenDbContext.cs
+++ b/SW.Bitween.PgSql/BitweenDbContext.cs
@@ -400,7 +400,11 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                         Disabled = false,
                         Password = defaultPasswordHash,
                         Role = AccountRole.Admin,
-                        FailedLoginCount = 0
+                        FailedLoginCount = 0,
+                        // True for a fresh installation, whose password is the published default.
+                        // Installations that already exist are handled by the migration, which
+                        // flags only those still holding that same value.
+                        MustChangePassword = true
                     });
             });
 
diff --git a/SW.Bitween.PgSql/Migrations/20260915090259_AddMustChangePassword.Designer.cs b/SW.Bitween.PgSql/Migrations/20260915090259_AddMustChangePassword.Designer.cs
new file mode 100644
index 00000000..c00b5cef
--- /dev/null
+++ b/SW.Bitween.PgSql/Migrations/20260915090259_AddMustChangePassword.Designer.cs
@@ -0,0 +1,2750 @@
+// <auto-generated />
+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using SW.Bitween.Model;
+using SW.Bitween.PgSql;
+
+#nullable disable
+
+namespace SW.Bitween.PgSql.Migrations
+{
+    [DbContext(typeof(BitweenDbContext))]
+    [Migration("20260915090259_AddMustChangePassword")]
+    partial class AddMustChangePassword
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("infolink")
+                .HasAnnotation("ProductVersion", "9.0.19")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.HasPostgresExtension(modelBuilder, "hstore");
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.Account", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("created_by");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<bool>("Deleted")
+                        .HasColumnType("boolean")
+                        .HasColumnName("deleted");
+
+                    b.Property<bool>("Disabled")
+                        .HasColumnType("boolean")
+                        .HasColumnName("disabled");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("display_name");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("email");
+
+                    b.Property<byte>("EmailProvider")
+                        .HasColumnType("smallint")
+                        .HasColumnName("email_provider");
+
+                    b.Property<int>("FailedLoginCount")
+                        .HasColumnType("integer")
+                        .HasColumnName("failed_login_count");
+
+                    b.Property<DateTime?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("lockout_end");
+
+                    b.Property<byte>("LoginMethods")
+                        .HasColumnType("smallint")
+                        .HasColumnName("login_methods");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("modified_by");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("modified_on");
+
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("boolean")
+                        .HasColumnName("must_change_password");
+
+                    b.Property<string>("Password")
+                        .HasMaxLength(500)
+                        .IsUnicode(false)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("password");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer")
+                        .HasColumnName("role");
+
+                    b.HasKey("Id")
+                        .HasName("pk_accounts");
+
+                    b.HasIndex("Email")
+                        .IsUnique()
+                        .HasDatabaseName("ix_accounts_email");
+
+                    b.ToTable("Accounts", "infolink");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 9999,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Deleted = false,
+                            Disabled = false,
+                            DisplayName = "Admin",
+                            Email = "admin@Bitween.systems",
+                            EmailProvider = (byte)0,
+                            FailedLoginCount = 0,
+                            LoginMethods = (byte)2,
+                            MustChangePassword = true,
+                            Password = "$SWHASH$V1$10000$VQCi48eitH4Ml5juvBMOFZrMdQwBbhuIQVXe6RR7qJdDF2bJ",
+                            Role = 0
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.AccountRoleLink", b =>
+                {
+                    b.Property<int>("AccountId")
+                        .HasColumnType("integer")
+                        .HasColumnName("account_id");
+
+                    b.Property<int>("RoleId")
+                        .HasColumnType("integer")
+                        .HasColumnName("role_id");
+
+                    b.HasKey("AccountId", "RoleId")
+                        .HasName("pk_account_roles");
+
+                    b.HasIndex("RoleId")
+                        .HasDatabaseName("ix_account_roles_role_id");
+
+                    b.ToTable("AccountRoles", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.RefreshToken", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("id");
+
+                    b.Property<int>("AccountId")
+                        .HasColumnType("integer")
+                        .HasColumnName("account_id");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<byte>("LoginMethod")
+                        .HasColumnType("smallint")
+                        .HasColumnName("login_method");
+
+                    b.HasKey("Id")
+                        .HasName("pk_refresh_tokens");
+
+                    b.HasIndex("AccountId")
+                        .HasDatabaseName("ix_refresh_tokens_account_id");
+
+                    b.ToTable("RefreshTokens", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.Role", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("created_by");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("description");
+
+                    b.Property<bool>("IsSystem")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_system");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("modified_by");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("modified_on");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("Permissions")
+                        .HasColumnType("text")
+                        .HasColumnName("permissions");
+
+                    b.HasKey("Id")
+                        .HasName("pk_roles");
+
+                    b.HasIndex("Name")
+                        .IsUnique()
+                        .HasDatabaseName("ix_roles_name");
+
+                    b.ToTable("Roles", "infolink");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Description = "Full access to everything, including members, roles and settings.",
+                            IsSystem = true,
+                            Name = "Administrator",
+                            Permissions = "[]"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Description = "Runs and configures integrations. Can't manage members, roles or settings.",
+                            IsSystem = true,
+                            Name = "Member",
+                            Permissions = "[]"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            CreatedOn = new DateTime(2022, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
+                            Description = "Read-only access to integrations, exchanges and configuration.",
+                            IsSystem = true,
+                            Name = "Viewer",
+                            Permissions = "[]"
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.AuditEntry", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(32)
+                        .IsUnicode(false)
+                        .HasColumnType("character varying(32)")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Changes")
+                        .HasColumnType("text")
+                        .HasColumnName("changes");
+
+                    b.Property<string>("CorrelationId")
+                        .IsRequired()
+                        .HasMaxLength(36)
+                        .IsUnicode(false)
+                        .HasColumnType("character varying(36)")
+                        .HasColumnName("correlation_id");
+
+                    b.Property<string>("EntityKey")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("entity_key");
+
+                    b.Property<string>("EntityName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("entity_name");
+
+                    b.Property<DateTime>("OccurredOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("occurred_on");
+
+                    b.Property<int>("Sequence")
+                        .HasColumnType("integer")
+                        .HasColumnName("sequence");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .IsUnicode(false)
+                        .HasColumnType("character varying(10)")
+                        .HasColumnName("state");
+
+                    b.Property<string>("UserId")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_audit_entries");
+
+                    b.HasIndex("CorrelationId")
+                        .HasDatabaseName("ix_audit_entries_correlation_id");
+
+                    b.HasIndex("OccurredOn")
+                        .HasDatabaseName("ix_audit_entries_occurred_on");
+
+                    b.HasIndex("EntityName", "EntityKey", "OccurredOn")
+                        .HasDatabaseName("ix_audit_entries_entity_name_entity_key_occurred_on");
+
+                    b.ToTable("AuditEntries", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Cluster.ClusterLease", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("AcquiredOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("acquired_on");
+
+                    b.Property<string>("OwnerNode")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("owner_node");
+
+                    b.Property<long>("Term")
+                        .HasColumnType("bigint")
+                        .HasColumnName("term");
+
+                    b.HasKey("Id")
+                        .HasName("pk_cluster_lease");
+
+                    b.ToTable("cluster_lease", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.AdapterState", b =>
+                {
+                    b.Property<string>("AdapterId")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("adapter_id");
+
+                    b.Property<string>("InstanceKey")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("instance_key");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("name");
+
+                    b.Property<DateTime>("UpdatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_on");
+
+                    b.Property<string>("Value")
+                        .HasMaxLength(8000)
+                        .HasColumnType("character varying(8000)")
+                        .HasColumnName("value");
+
+                    b.HasKey("AdapterId", "InstanceKey", "Name")
+                        .HasName("pk_adapter_state");
+
+                    b.ToTable("adapter_state", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.DataSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AdapterId")
+                        .HasColumnType("text")
+                        .HasColumnName("adapter_id");
+
+                    b.Property<int>("ConsecutiveFailures")
+                        .HasColumnType("integer")
+                        .HasColumnName("consecutive_failures");
+
+                    b.Property<int>("CpuLimitSamples")
+                        .HasColumnType("integer")
+                        .HasColumnName("cpu_limit_samples");
+
+                    b.Property<double>("CpuPercentLimit")
+                        .HasColumnType("double precision")
+                        .HasColumnName("cpu_percent_limit");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("created_by");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<int>("DeduplicationWindowDays")
+                        .HasColumnType("integer")
+                        .HasColumnName("deduplication_window_days");
+
+                    b.Property<int>("HardMemoryLimitMb")
+                        .HasColumnType("integer")
+                        .HasColumnName("hard_memory_limit_mb");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("boolean")
+                        .HasColumnName("inactive");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("integer")
+                        .HasColumnName("kind");
+
+                    b.Property<string>("LastException")
+                        .HasColumnType("text")
+                        .HasColumnName("last_exception");
+
+                    b.Property<DateTime?>("LastHeartbeatOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_heartbeat_on");
+
+                    b.Property<string>("LastKnownState")
+                        .HasColumnType("text")
+                        .HasColumnName("last_known_state");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("modified_by");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("modified_on");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.Property<string>("OwnedByNode")
+                        .HasColumnType("text")
+                        .HasColumnName("owned_by_node");
+
+                    b.Property<int>("Placement")
+                        .HasColumnType("integer")
+                        .HasColumnName("placement");
+
+                    b.Property<Dictionary<string, string>>("Properties")
+                        .HasColumnType("hstore")
+                        .HasColumnName("properties");
+
+                    b.PrimitiveCollection<List<string>>("SecretProperties")
+                        .HasColumnType("text[]")
+                        .HasColumnName("secret_properties");
+
+                    b.Property<int>("SoftMemoryLimitMb")
+                        .HasColumnType("integer")
+                        .HasColumnName("soft_memory_limit_mb");
+
+                    b.HasKey("Id")
+                        .HasName("pk_data_source");
+
+                    b.ToTable("data_source", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.DataSourceStatement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("created_by");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<string>("CursorColumn")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasColumnName("cursor_column");
+
+                    b.Property<int>("DataSourceId")
+                        .HasColumnType("integer")
+                        .HasColumnName("data_source_id");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)")
+                        .HasColumnName("description");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("boolean")
+                        .HasColumnName("inactive");
+
+                    b.Property<string>("KeyColumn")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasColumnName("key_column");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("modified_by");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("modified_on");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("Sql")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("sql");
+
+                    b.Property<int?>("WorkGroupId")
+                        .HasColumnType("integer")
+                        .HasColumnName("work_group_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_data_source_statement");
+
+                    b.HasIndex("WorkGroupId")
+                        .HasDatabaseName("ix_data_source_statement_work_group_id");
+
+                    b.HasIndex("DataSourceId", "Name")
+                        .IsUnique()
+                        .HasDatabaseName("ix_data_source_statement_data_source_id_name");
+
+                    b.ToTable("data_source_statement", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.InboundMessage", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(400)
+                        .HasColumnType("character varying(400)")
+                        .HasColumnName("id");
+
+                    b.Property<int>("DataSourceId")
+                        .HasColumnType("integer")
+                        .HasColumnName("data_source_id");
+
+                    b.Property<DateTime>("SeenOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("seen_on");
+
+                    b.Property<string>("XchangeId")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("xchange_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_inbound_message");
+
+                    b.HasIndex("DataSourceId")
+                        .HasDatabaseName("ix_inbound_message_data_source_id");
+
+                    b.HasIndex("SeenOn")
+                        .HasDatabaseName("ix_inbound_message_seen_on");
+
+                    b.ToTable("inbound_message", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DelayedRetry", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("On")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("on");
+
+                    b.HasKey("Id")
+                        .HasName("pk_delayed_retry");
+
+                    b.HasIndex("On")
+                        .HasDatabaseName("ix_delayed_retry_on");
+
+                    b.ToTable("delayed_retry", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Document", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("BusEnabled")
+                        .HasColumnType("boolean")
+                        .HasColumnName("bus_enabled");
+
+                    b.Property<string>("BusMessageTypeName")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("bus_message_type_name");
+
+                    b.Property<string>("Code")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("code");
+
+                    b.Property<bool?>("DisregardsUnfilteredMessages")
+                        .HasColumnType("boolean")
+                        .HasColumnName("disregards_unfiltered_messages");
+
+                    b.Property<int>("DocumentFormat")
+                        .HasColumnType("integer")
+                        .HasColumnName("document_format");
+
+                    b.Property<int>("DuplicateInterval")
+                        .HasColumnType("integer")
+                        .HasColumnName("duplicate_interval");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("PromotedProperties")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("promoted_properties");
+
+                    b.Property<DateTime?>("RetiredOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("retired_on");
+
+                    b.HasKey("Id")
+                        .HasName("pk_document");
+
+                    b.HasIndex("BusMessageTypeName")
+                        .IsUnique()
+                        .HasDatabaseName("ix_document_bus_message_type_name");
+
+                    b.HasIndex("Code")
+                        .IsUnique()
+                        .HasDatabaseName("ix_document_code");
+
+                    b.HasIndex("Name")
+                        .IsUnique()
+                        .HasDatabaseName("ix_document_name");
+
+                    b.ToTable("document", "infolink");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 10001,
+                            BusEnabled = false,
+                            DocumentFormat = 0,
+                            DuplicateInterval = 0,
+                            Name = "Aggregation Document",
+                            PromotedProperties = "{}"
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGateway", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("created_by");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("boolean")
+                        .HasColumnName("inactive");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("modified_by");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("modified_on");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("UrlName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("url_name");
+
+                    b.HasKey("Id")
+                        .HasName("pk_api_gateway");
+
+                    b.HasIndex("UrlName")
+                        .IsUnique()
+                        .HasDatabaseName("ix_api_gateway_url_name");
+
+                    b.ToTable("api_gateway", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGatewayPartner", b =>
+                {
+                    b.Property<int>("ApiGatewayId")
+                        .HasColumnType("integer")
+                        .HasColumnName("api_gateway_id");
+
+                    b.Property<int>("PartnerId")
+                        .HasColumnType("integer")
+                        .HasColumnName("partner_id");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("subscription_id");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("created_by");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("modified_by");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("modified_on");
+
+                    b.HasKey("ApiGatewayId", "PartnerId", "SubscriptionId")
+                        .HasName("pk_api_gateway_partner");
+
+                    b.HasIndex("PartnerId")
+                        .HasDatabaseName("ix_api_gateway_partner_partner_id");
+
+                    b.HasIndex("SubscriptionId")
+                        .HasDatabaseName("ix_api_gateway_partner_subscription_id");
+
+                    b.ToTable("api_gateway_partner", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGateway", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("created_by");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<int?>("DataSourceId")
+                        .HasColumnType("integer")
+                        .HasColumnName("data_source_id");
+
+                    b.Property<int>("DocumentId")
+                        .HasColumnType("integer")
+                        .HasColumnName("document_id");
+
+                    b.Property<string>("Endpoint")
+                        .HasColumnType("text")
+                        .HasColumnName("endpoint");
+
+                    b.Property<Dictionary<string, string>>("EndpointProperties")
+                        .HasColumnType("hstore")
+                        .HasColumnName("endpoint_properties");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("boolean")
+                        .HasColumnName("inactive");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("modified_by");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("modified_on");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("pk_bus_gateway");
+
+                    b.HasIndex("DataSourceId")
+                        .HasDatabaseName("ix_bus_gateway_data_source_id");
+
+                    b.HasIndex("DocumentId")
+                        .HasDatabaseName("ix_bus_gateway_document_id");
+
+                    b.ToTable("bus_gateway", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGatewayRoute", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BusGatewayId")
+                        .HasColumnType("integer")
+                        .HasColumnName("bus_gateway_id");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("created_by");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<string>("MatchExpression")
+                        .HasColumnType("text")
+                        .HasColumnName("match_expression");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("modified_by");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("modified_on");
+
+                    b.Property<int?>("PartnerId")
+                        .HasColumnType("integer")
+                        .HasColumnName("partner_id");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("subscription_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_bus_gateway_route");
+
+                    b.HasIndex("BusGatewayId")
+                        .HasDatabaseName("ix_bus_gateway_route_bus_gateway_id");
+
+                    b.HasIndex("PartnerId")
+                        .HasDatabaseName("ix_bus_gateway_route_partner_id");
+
+                    b.HasIndex("SubscriptionId")
+                        .HasDatabaseName("ix_bus_gateway_route_subscription_id");
+
+                    b.ToTable("bus_gateway_route", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.GlobalAdapterValuesSet", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.Property<Dictionary<string, string>>("Values")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("values");
+
+                    b.HasKey("Id")
+                        .HasName("pk_global_adapter_values_set");
+
+                    b.ToTable("global_adapter_values_set", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Notifier", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("HandlerId")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("handler_id");
+
+                    b.Property<string>("HandlerProperties")
+                        .HasColumnType("text")
+                        .HasColumnName("handler_properties");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("boolean")
+                        .HasColumnName("inactive");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("name");
+
+                    b.Property<bool>("RunOnBadResult")
+                        .HasColumnType("boolean")
+                        .HasColumnName("run_on_bad_result");
+
+                    b.Property<bool>("RunOnFailedResult")
+                        .HasColumnType("boolean")
+                        .HasColumnName("run_on_failed_result");
+
+                    b.PrimitiveCollection<int[]>("RunOnSubscriptions")
+                        .HasColumnType("integer[]")
+                        .HasColumnName("run_on_subscriptions");
+
+                    b.Property<bool>("RunOnSuccessfulResult")
+                        .HasColumnType("boolean")
+                        .HasColumnName("run_on_successful_result");
+
+                    b.HasKey("Id")
+                        .HasName("pk_notifier");
+
+                    b.ToTable("notifier", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.OnHoldXchange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<bool>("BadData")
+                        .HasColumnType("boolean")
+                        .HasColumnName("bad_data");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("text")
+                        .HasColumnName("data");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text")
+                        .HasColumnName("file_name");
+
+                    b.PrimitiveCollection<string[]>("References")
+                        .HasColumnType("text[]")
+                        .HasColumnName("references");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("subscription_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_on_hold_xchange");
+
+                    b.HasIndex("SubscriptionId")
+                        .HasDatabaseName("ix_on_hold_xchange_subscription_id");
+
+                    b.ToTable("on_hold_xchange", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Partner", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Dictionary<string, string>>("AdapterProperties")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("adapter_properties");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("pk_partner");
+
+                    b.ToTable("partner", "infolink");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            Name = "SYSTEM"
+                        });
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.ReceiveAttempt", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ErrorMessage")
+                        .HasColumnType("text")
+                        .HasColumnName("error_message");
+
+                    b.PrimitiveCollection<string[]>("ExchangeIds")
+                        .HasColumnType("text[]")
+                        .HasColumnName("exchange_ids");
+
+                    b.Property<DateTime>("FinishedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("finished_on");
+
+                    b.Property<int>("Outcome")
+                        .HasColumnType("integer")
+                        .HasColumnName("outcome");
+
+                    b.Property<DateTime>("StartedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("started_on");
+
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("subscription_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_receive_attempt");
+
+                    b.HasIndex("SubscriptionId", "StartedOn")
+                        .HasDatabaseName("ix_receive_attempt_subscription_id_started_on");
+
+                    b.ToTable("receive_attempt", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.RetryAlertOverride", b =>
+                {
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("subscription_id");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("group_id");
+
+                    b.Property<string>("AlertHandlerId")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("alert_handler_id");
+
+                    b.Property<string>("AlertHandlerProperties")
+                        .HasColumnType("text")
+                        .HasColumnName("alert_handler_properties");
+
+                    b.Property<byte>("AlertMode")
+                        .HasColumnType("smallint")
+                        .HasColumnName("alert_mode");
+
+                    b.HasKey("SubscriptionId", "GroupId")
+                        .HasName("pk_retry_alert_override");
+
+                    b.ToTable("retry_alert_override", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.RetryGroupUsage", b =>
+                {
+                    b.Property<int>("SubscriptionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("subscription_id");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("group_id");
+
+                    b.Property<int>("AttemptsUsed")
+                        .HasColumnType("integer")
+                        .HasColumnName("attempts_used");
+
+                    b.Property<DateTime?>("ExhaustedNotifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("exhausted_notified_on");
+
+                    b.Property<DateTime>("LastAttemptOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_attempt_on");
+
+                    b.HasKey("SubscriptionId", "GroupId")
+                        .HasName("pk_retry_group_usage");
+
+                    b.ToTable("retry_group_usage", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.RetryPolicy", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlertHandlerId")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("alert_handler_id");
+
+                    b.Property<string>("AlertHandlerProperties")
+                        .HasColumnType("text")
+                        .HasColumnName("alert_handler_properties");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("created_by");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<string>("Groups")
+                        .HasColumnType("text")
+                        .HasColumnName("groups");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("modified_by");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("modified_on");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("pk_retry_policy");
+
+                    b.ToTable("retry_policy", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Setting", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(200)
+                        .IsUnicode(false)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("id");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("created_by");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("modified_by");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("modified_on");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text")
+                        .HasColumnName("value");
+
+                    b.HasKey("Id")
+                        .HasName("pk_settings");
+
+                    b.ToTable("Settings", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Subscription", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("AggregateOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("aggregate_on");
+
+                    b.Property<int?>("AggregationForId")
+                        .HasColumnType("integer")
+                        .HasColumnName("aggregation_for_id");
+
+                    b.Property<byte>("AggregationTarget")
+                        .HasColumnType("smallint")
+                        .HasColumnName("aggregation_target");
+
+                    b.Property<int?>("CategoryId")
+                        .HasColumnType("integer")
+                        .HasColumnName("category_id");
+
+                    b.Property<int>("ConsecutiveFailures")
+                        .HasColumnType("integer")
+                        .HasColumnName("consecutive_failures");
+
+                    b.Property<string>("CustomRetryPolicy")
+                        .HasColumnType("text")
+                        .HasColumnName("custom_retry_policy");
+
+                    b.Property<int?>("DataSourceId")
+                        .HasColumnType("integer")
+                        .HasColumnName("data_source_id");
+
+                    b.Property<IReadOnlyDictionary<string, string>>("DocumentFilter")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("document_filter");
+
+                    b.Property<int>("DocumentId")
+                        .HasColumnType("integer")
+                        .HasColumnName("document_id");
+
+                    b.Property<string>("HandlerId")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("handler_id");
+
+                    b.Property<IReadOnlyDictionary<string, string>>("HandlerProperties")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("handler_properties");
+
+                    b.Property<bool>("Inactive")
+                        .HasColumnType("boolean")
+                        .HasColumnName("inactive");
+
+                    b.Property<bool>("IsRunning")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_running");
+
+                    b.Property<string>("LastException")
+                        .HasColumnType("text")
+                        .HasColumnName("last_exception");
+
+                    b.Property<string>("MapperId")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("mapper_id");
+
+                    b.Property<IReadOnlyDictionary<string, string>>("MapperProperties")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("mapper_properties");
+
+                    b.Property<string>("MatchExpression")
+                        .HasColumnType("text")
+                        .HasColumnName("match_expression");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("name");
+
+                    b.Property<int?>("PartnerId")
+                        .HasColumnType("integer")
+                        .HasColumnName("partner_id");
+
+                    b.Property<DateTime?>("PausedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("paused_on");
+
+                    b.Property<DateTime?>("ReceiveOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("receive_on");
+
+                    b.Property<string>("ReceiverId")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("receiver_id");
+
+                    b.Property<IReadOnlyDictionary<string, string>>("ReceiverProperties")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("receiver_properties");
+
+                    b.Property<string>("ResponseMessageTypeName")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("response_message_type_name");
+
+                    b.Property<int?>("ResponseSubscriptionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("response_subscription_id");
+
+                    b.Property<int?>("RetryPolicyId")
+                        .HasColumnType("integer")
+                        .HasColumnName("retry_policy_id");
+
+                    b.Property<bool>("Temporary")
+                        .HasColumnType("boolean")
+                        .HasColumnName("temporary");
+
+                    b.Property<byte>("Type")
+                        .HasColumnType("smallint")
+                        .HasColumnName("type");
+
+                    b.Property<string>("ValidatorId")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("validator_id");
+
+                    b.Property<IReadOnlyDictionary<string, string>>("ValidatorProperties")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("validator_properties");
+
+                    b.Property<int?>("WorkGroupId")
+                        .HasColumnType("integer")
+                        .HasColumnName("work_group_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_subscription");
+
+                    b.HasIndex("AggregationForId")
+                        .HasDatabaseName("ix_subscription_aggregation_for_id");
+
+                    b.HasIndex("CategoryId")
+                        .HasDatabaseName("ix_subscription_category_id");
+
+                    b.HasIndex("DataSourceId")
+                        .HasDatabaseName("ix_subscription_data_source_id");
+
+                    b.HasIndex("DocumentId")
+                        .HasDatabaseName("ix_subscription_document_id");
+
+                    b.HasIndex("PartnerId")
+                        .HasDatabaseName("ix_subscription_partner_id");
+
+                    b.HasIndex("ResponseSubscriptionId")
+                        .HasDatabaseName("ix_subscription_response_subscription_id");
+
+                    b.HasIndex("RetryPolicyId")
+                        .HasDatabaseName("ix_subscription_retry_policy_id");
+
+                    b.HasIndex("WorkGroupId")
+                        .HasDatabaseName("ix_subscription_work_group_id");
+
+                    b.ToTable("subscription", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.SubscriptionCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .HasColumnType("text")
+                        .HasColumnName("code");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("created_by");
+
+                    b.Property<DateTime>("CreatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_on");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text")
+                        .HasColumnName("description");
+
+                    b.Property<string>("ModifiedBy")
+                        .HasColumnType("text")
+                        .HasColumnName("modified_by");
+
+                    b.Property<DateTime?>("ModifiedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("modified_on");
+
+                    b.HasKey("Id")
+                        .HasName("pk_subscription_category");
+
+                    b.HasIndex("Code")
+                        .IsUnique()
+                        .HasDatabaseName("ix_subscription_category_code");
+
+                    b.ToTable("subscription_category", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.WorkGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("BusMessageName")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .IsUnicode(false)
+                        .HasColumnType("character varying(100)")
+                        .HasColumnName("bus_message_name");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.Property<WorkGroupOptions>("Options")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("options");
+
+                    b.HasKey("Id")
+                        .HasName("pk_work_group");
+
+                    b.ToTable("work_group", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Xchange", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("id");
+
+                    b.Property<string>("CorrelationId")
+                        .HasColumnType("text")
+                        .HasColumnName("correlation_id");
+
+                    b.Property<int>("DocumentId")
+                        .HasColumnType("integer")
+                        .HasColumnName("document_id");
+
+                    b.Property<string>("HandlerId")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("handler_id");
+
+                    b.Property<IReadOnlyDictionary<string, string>>("HandlerProperties")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("handler_properties");
+
+                    b.Property<string>("InputContentType")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("input_content_type");
+
+                    b.Property<string>("InputHash")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("input_hash");
+
+                    b.Property<string>("InputName")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("input_name");
+
+                    b.Property<int>("InputSize")
+                        .HasColumnType("integer")
+                        .HasColumnName("input_size");
+
+                    b.Property<bool>("ManualRetry")
+                        .HasColumnType("boolean")
+                        .HasColumnName("manual_retry");
+
+                    b.Property<string>("MapperId")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("mapper_id");
+
+                    b.Property<IReadOnlyDictionary<string, string>>("MapperProperties")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("mapper_properties");
+
+                    b.Property<int?>("PartnerId")
+                        .HasColumnType("integer")
+                        .HasColumnName("partner_id");
+
+                    b.PrimitiveCollection<string[]>("References")
+                        .HasColumnType("text[]")
+                        .HasColumnName("references");
+
+                    b.Property<string>("ResponseMessageTypeName")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("response_message_type_name");
+
+                    b.Property<int?>("ResponseSubscriptionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("response_subscription_id");
+
+                    b.Property<string>("RetryFor")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("retry_for");
+
+                    b.Property<DateTime>("StartedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("started_on");
+
+                    b.Property<int?>("SubscriptionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("subscription_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_xchange");
+
+                    b.HasIndex("DocumentId")
+                        .HasDatabaseName("ix_xchange_document_id");
+
+                    b.HasIndex("InputHash")
+                        .HasDatabaseName("ix_xchange_input_hash");
+
+                    b.HasIndex("RetryFor")
+                        .HasDatabaseName("ix_xchange_retry_for");
+
+                    b.HasIndex("StartedOn")
+                        .HasDatabaseName("ix_xchange_started_on");
+
+                    b.HasIndex("SubscriptionId")
+                        .HasDatabaseName("ix_xchange_subscription_id");
+
+                    b.ToTable("xchange", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeAggregation", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("AggregatedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("aggregated_on");
+
+                    b.Property<string>("AggregationXchangeId")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("aggregation_xchange_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_xchange_aggregation");
+
+                    b.HasIndex("AggregationXchangeId")
+                        .HasDatabaseName("ix_xchange_aggregation_aggregation_xchange_id");
+
+                    b.ToTable("xchange_aggregation", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeDelivery", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("DeliveredOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("delivered_on");
+
+                    b.HasKey("Id")
+                        .HasName("pk_xchange_delivery");
+
+                    b.HasIndex("DeliveredOn")
+                        .HasDatabaseName("ix_xchange_delivery_delivered_on");
+
+                    b.ToTable("xchange_delivery", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeNotification", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Exception")
+                        .HasColumnType("text")
+                        .HasColumnName("exception");
+
+                    b.Property<DateTime>("FinishedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("finished_on");
+
+                    b.Property<int?>("NotifierId")
+                        .HasColumnType("integer")
+                        .HasColumnName("notifier_id");
+
+                    b.Property<string>("NotifierName")
+                        .HasColumnType("text")
+                        .HasColumnName("notifier_name");
+
+                    b.Property<bool>("Success")
+                        .HasColumnType("boolean")
+                        .HasColumnName("success");
+
+                    b.Property<string>("XchangeId")
+                        .HasMaxLength(50)
+                        .IsUnicode(false)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("xchange_id");
+
+                    b.HasKey("Id")
+                        .HasName("pk_xchange_notification");
+
+                    b.ToTable("xchange_notification", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangePromotedProperties", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("id");
+
+                    b.PrimitiveCollection<int[]>("Hits")
+                        .HasColumnType("integer[]")
+                        .HasColumnName("hits");
+
+                    b.Property<IReadOnlyDictionary<string, string>>("Properties")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("properties");
+
+                    b.Property<string>("PropertiesRaw")
+                        .HasColumnType("text")
+                        .HasColumnName("properties_raw");
+
+                    b.HasKey("Id")
+                        .HasName("pk_xchange_promoted_properties");
+
+                    b.HasIndex("PropertiesRaw")
+                        .HasDatabaseName("ix_xchange_promoted_properties_properties_raw");
+
+                    b.ToTable("xchange_promoted_properties", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeResult", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("id");
+
+                    b.Property<int?>("AttemptNumber")
+                        .HasColumnType("integer")
+                        .HasColumnName("attempt_number");
+
+                    b.Property<string>("Exception")
+                        .HasColumnType("text")
+                        .HasColumnName("exception");
+
+                    b.Property<DateTime>("FinishedOn")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("finished_on");
+
+                    b.Property<bool>("OutputBad")
+                        .HasColumnType("boolean")
+                        .HasColumnName("output_bad");
+
+                    b.Property<string>("OutputContentType")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("output_content_type");
+
+                    b.Property<string>("OutputHash")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("output_hash");
+
+                    b.Property<string>("OutputName")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("output_name");
+
+                    b.Property<int>("OutputSize")
+                        .HasColumnType("integer")
+                        .HasColumnName("output_size");
+
+                    b.Property<bool>("ResponseBad")
+                        .HasColumnType("boolean")
+                        .HasColumnName("response_bad");
+
+                    b.Property<string>("ResponseContentType")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("response_content_type");
+
+                    b.Property<string>("ResponseHash")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)")
+                        .HasColumnName("response_hash");
+
+                    b.Property<string>("ResponseName")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)")
+                        .HasColumnName("response_name");
+
+                    b.Property<int>("ResponseSize")
+                        .HasColumnType("integer")
+                        .HasColumnName("response_size");
+
+                    b.Property<string>("ResponseXchangeId")
+                        .HasColumnType("text")
+                        .HasColumnName("response_xchange_id");
+
+                    b.Property<string>("RetryBlockedReason")
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)")
+                        .HasColumnName("retry_blocked_reason");
+
+                    b.Property<Guid?>("RetryGroupId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("retry_group_id");
+
+                    b.Property<bool>("Success")
+                        .HasColumnType("boolean")
+                        .HasColumnName("success");
+
+                    b.HasKey("Id")
+                        .HasName("pk_xchange_result");
+
+                    b.HasIndex("RetryGroupId")
+                        .HasDatabaseName("ix_xchange_result_retry_group_id");
+
+                    b.ToTable("xchange_result", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.RunFlagUpdater+RunningResult", b =>
+                {
+                    b.Property<bool>("IsRunning")
+                        .HasColumnType("boolean")
+                        .HasColumnName("is_running");
+
+                    b.ToTable("running_result", "infolink");
+
+                    b.ToView(null, (string)null);
+                });
+
+            modelBuilder.Entity("SW.Scheduler.JobExecution", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Context")
+                        .HasColumnType("text")
+                        .HasColumnName("context");
+
+                    b.Property<long?>("DurationMs")
+                        .HasColumnType("bigint")
+                        .HasColumnName("duration_ms");
+
+                    b.Property<DateTime?>("EndTimeUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("end_time_utc");
+
+                    b.Property<string>("Error")
+                        .HasColumnType("text")
+                        .HasColumnName("error");
+
+                    b.Property<string>("FireInstanceId")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("fire_instance_id");
+
+                    b.Property<string>("JobGroup")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_name");
+
+                    b.Property<string>("JobTypeName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_type_name");
+
+                    b.Property<string>("Node")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("node");
+
+                    b.Property<DateTime>("StartTimeUtc")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("start_time_utc");
+
+                    b.Property<bool?>("Success")
+                        .HasColumnType("boolean")
+                        .HasColumnName("success");
+
+                    b.HasKey("Id")
+                        .HasName("pk_job_executions");
+
+                    b.HasIndex("FireInstanceId")
+                        .IsUnique()
+                        .HasDatabaseName("idx_je_fire_instance_id");
+
+                    b.HasIndex("StartTimeUtc")
+                        .HasDatabaseName("idx_je_start_time");
+
+                    b.HasIndex("Success")
+                        .HasDatabaseName("idx_je_success");
+
+                    b.HasIndex("JobGroup", "JobName", "StartTimeUtc")
+                        .HasDatabaseName("idx_je_group_name_start");
+
+                    b.ToTable("job_executions", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzBlobTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<byte[]>("BlobData")
+                        .HasColumnType("bytea")
+                        .HasColumnName("blob_data");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .HasName("pk_qrtz_blob_triggers");
+
+                    b.ToTable("qrtz_blob_triggers", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzCalendar", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("CalendarName")
+                        .HasColumnType("text")
+                        .HasColumnName("calendar_name");
+
+                    b.Property<byte[]>("Calendar")
+                        .IsRequired()
+                        .HasColumnType("bytea")
+                        .HasColumnName("calendar");
+
+                    b.HasKey("SchedulerName", "CalendarName")
+                        .HasName("pk_qrtz_calendars");
+
+                    b.ToTable("qrtz_calendars", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzCronTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("CronExpression")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("cron_expression");
+
+                    b.Property<string>("TimeZoneId")
+                        .HasColumnType("text")
+                        .HasColumnName("time_zone_id");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .HasName("pk_qrtz_cron_triggers");
+
+                    b.ToTable("qrtz_cron_triggers", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzFiredTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("EntryId")
+                        .HasColumnType("text")
+                        .HasColumnName("entry_id");
+
+                    b.Property<long>("FiredTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("fired_time");
+
+                    b.Property<string>("InstanceName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("instance_name");
+
+                    b.Property<bool>("IsNonConcurrent")
+                        .HasColumnType("bool")
+                        .HasColumnName("is_nonconcurrent");
+
+                    b.Property<string>("JobGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("JobName")
+                        .HasColumnType("text")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("integer")
+                        .HasColumnName("priority");
+
+                    b.Property<bool?>("RequestsRecovery")
+                        .HasColumnType("bool")
+                        .HasColumnName("requests_recovery");
+
+                    b.Property<long>("ScheduledTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("sched_time");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("state");
+
+                    b.Property<string>("TriggerGroup")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("TriggerName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.HasKey("SchedulerName", "EntryId")
+                        .HasName("pk_qrtz_fired_triggers");
+
+                    b.HasIndex("InstanceName")
+                        .HasDatabaseName("idx_qrtz_ft_trig_inst_name");
+
+                    b.HasIndex("JobGroup")
+                        .HasDatabaseName("idx_qrtz_ft_job_group");
+
+                    b.HasIndex("JobName")
+                        .HasDatabaseName("idx_qrtz_ft_job_name");
+
+                    b.HasIndex("RequestsRecovery")
+                        .HasDatabaseName("idx_qrtz_ft_job_req_recovery");
+
+                    b.HasIndex("TriggerGroup")
+                        .HasDatabaseName("idx_qrtz_ft_trig_group");
+
+                    b.HasIndex("TriggerName")
+                        .HasDatabaseName("idx_qrtz_ft_trig_name");
+
+                    b.HasIndex("SchedulerName", "TriggerName", "TriggerGroup")
+                        .HasDatabaseName("idx_qrtz_ft_trig_nm_gp");
+
+                    b.ToTable("qrtz_fired_triggers", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzJobDetail", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("JobName")
+                        .HasColumnType("text")
+                        .HasColumnName("job_name");
+
+                    b.Property<string>("JobGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text")
+                        .HasColumnName("description");
+
+                    b.Property<bool>("IsDurable")
+                        .HasColumnType("bool")
+                        .HasColumnName("is_durable");
+
+                    b.Property<bool>("IsNonConcurrent")
+                        .HasColumnType("bool")
+                        .HasColumnName("is_nonconcurrent");
+
+                    b.Property<bool>("IsUpdateData")
+                        .HasColumnType("bool")
+                        .HasColumnName("is_update_data");
+
+                    b.Property<string>("JobClassName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_class_name");
+
+                    b.Property<byte[]>("JobData")
+                        .HasColumnType("bytea")
+                        .HasColumnName("job_data");
+
+                    b.Property<bool>("RequestsRecovery")
+                        .HasColumnType("bool")
+                        .HasColumnName("requests_recovery");
+
+                    b.HasKey("SchedulerName", "JobName", "JobGroup")
+                        .HasName("pk_qrtz_job_details");
+
+                    b.HasIndex("RequestsRecovery")
+                        .HasDatabaseName("idx_j_req_recovery");
+
+                    b.ToTable("qrtz_job_details", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzLock", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("LockName")
+                        .HasColumnType("text")
+                        .HasColumnName("lock_name");
+
+                    b.HasKey("SchedulerName", "LockName")
+                        .HasName("pk_qrtz_locks");
+
+                    b.ToTable("qrtz_locks", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzPausedTriggerGroup", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.HasKey("SchedulerName", "TriggerGroup")
+                        .HasName("pk_qrtz_paused_trigger_grps");
+
+                    b.ToTable("qrtz_paused_trigger_grps", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSchedulerState", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("InstanceName")
+                        .HasColumnType("text")
+                        .HasColumnName("instance_name");
+
+                    b.Property<long>("CheckInInterval")
+                        .HasColumnType("bigint")
+                        .HasColumnName("checkin_interval");
+
+                    b.Property<long>("LastCheckInTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("last_checkin_time");
+
+                    b.HasKey("SchedulerName", "InstanceName")
+                        .HasName("pk_qrtz_scheduler_state");
+
+                    b.ToTable("qrtz_scheduler_state", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimplePropertyTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<bool?>("BooleanProperty1")
+                        .HasColumnType("bool")
+                        .HasColumnName("bool_prop_1");
+
+                    b.Property<bool?>("BooleanProperty2")
+                        .HasColumnType("bool")
+                        .HasColumnName("bool_prop_2");
+
+                    b.Property<decimal?>("DecimalProperty1")
+                        .HasColumnType("numeric")
+                        .HasColumnName("dec_prop_1");
+
+                    b.Property<decimal?>("DecimalProperty2")
+                        .HasColumnType("numeric")
+                        .HasColumnName("dec_prop_2");
+
+                    b.Property<int?>("IntegerProperty1")
+                        .HasColumnType("integer")
+                        .HasColumnName("int_prop_1");
+
+                    b.Property<int?>("IntegerProperty2")
+                        .HasColumnType("integer")
+                        .HasColumnName("int_prop_2");
+
+                    b.Property<long?>("LongProperty1")
+                        .HasColumnType("bigint")
+                        .HasColumnName("long_prop_1");
+
+                    b.Property<long?>("LongProperty2")
+                        .HasColumnType("bigint")
+                        .HasColumnName("long_prop_2");
+
+                    b.Property<string>("StringProperty1")
+                        .HasColumnType("text")
+                        .HasColumnName("str_prop_1");
+
+                    b.Property<string>("StringProperty2")
+                        .HasColumnType("text")
+                        .HasColumnName("str_prop_2");
+
+                    b.Property<string>("StringProperty3")
+                        .HasColumnType("text")
+                        .HasColumnName("str_prop_3");
+
+                    b.Property<string>("TimeZoneId")
+                        .HasColumnType("text")
+                        .HasColumnName("time_zone_id");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .HasName("pk_qrtz_simprop_triggers");
+
+                    b.ToTable("qrtz_simprop_triggers", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimpleTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<long>("RepeatCount")
+                        .HasColumnType("bigint")
+                        .HasColumnName("repeat_count");
+
+                    b.Property<long>("RepeatInterval")
+                        .HasColumnType("bigint")
+                        .HasColumnName("repeat_interval");
+
+                    b.Property<long>("TimesTriggered")
+                        .HasColumnType("bigint")
+                        .HasColumnName("times_triggered");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .HasName("pk_qrtz_simple_triggers");
+
+                    b.ToTable("qrtz_simple_triggers", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("CalendarName")
+                        .HasColumnType("text")
+                        .HasColumnName("calendar_name");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text")
+                        .HasColumnName("description");
+
+                    b.Property<long?>("EndTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("end_time");
+
+                    b.Property<byte[]>("JobData")
+                        .HasColumnType("bytea")
+                        .HasColumnName("job_data");
+
+                    b.Property<string>("JobGroup")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_name");
+
+                    b.Property<int?>("MisfireInstruction")
+                        .HasColumnType("integer")
+                        .HasColumnName("misfire_instr");
+
+                    b.Property<long?>("NextFireTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("next_fire_time");
+
+                    b.Property<long?>("PreviousFireTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("prev_fire_time");
+
+                    b.Property<int?>("Priority")
+                        .HasColumnType("integer")
+                        .HasColumnName("priority");
+
+                    b.Property<long>("StartTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("start_time");
+
+                    b.Property<string>("TriggerState")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_state");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_type");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .HasName("pk_qrtz_triggers");
+
+                    b.HasIndex("NextFireTime")
+                        .HasDatabaseName("idx_t_next_fire_time");
+
+                    b.HasIndex("TriggerState")
+                        .HasDatabaseName("idx_t_state");
+
+                    b.HasIndex("NextFireTime", "TriggerState")
+                        .HasDatabaseName("idx_t_nft_st");
+
+                    b.HasIndex("SchedulerName", "JobName", "JobGroup")
+                        .HasDatabaseName("ix_qrtz_triggers_sched_name_job_name_job_group");
+
+                    b.ToTable("qrtz_triggers", "infolink");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.AccountRoleLink", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Accounts.Account", null)
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_account_roles_accounts_account_id");
+
+                    b.HasOne("SW.Bitween.Domain.Accounts.Role", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_account_roles_roles_role_id");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Accounts.RefreshToken", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Accounts.Account", null)
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_refresh_tokens_accounts_account_id");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.DataSourceStatement", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", "DataSource")
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_data_source_statement_data_source_data_source_id");
+
+                    b.HasOne("SW.Bitween.Domain.WorkGroup", null)
+                        .WithMany()
+                        .HasForeignKey("WorkGroupId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("fk_data_source_statement_work_group_work_group_id");
+
+                    b.Navigation("DataSource");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.DataSources.InboundMessage", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", null)
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_inbound_message_data_source_data_source_id");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGatewayPartner", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Gateway.ApiGateway", "ApiGateway")
+                        .WithMany("Partners")
+                        .HasForeignKey("ApiGatewayId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired()
+                        .HasConstraintName("fk_api_gateway_partner_api_gateway_api_gateway_id");
+
+                    b.HasOne("SW.Bitween.Domain.Partner", "Partner")
+                        .WithMany()
+                        .HasForeignKey("PartnerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired()
+                        .HasConstraintName("fk_api_gateway_partner_partner_partner_id");
+
+                    b.HasOne("SW.Bitween.Domain.Subscription", "Subscription")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired()
+                        .HasConstraintName("fk_api_gateway_partner_subscription_subscription_id");
+
+                    b.Navigation("ApiGateway");
+
+                    b.Navigation("Partner");
+
+                    b.Navigation("Subscription");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGateway", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", "DataSource")
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .HasConstraintName("fk_bus_gateway_data_source_data_source_id");
+
+                    b.HasOne("SW.Bitween.Domain.Document", null)
+                        .WithMany()
+                        .HasForeignKey("DocumentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired()
+                        .HasConstraintName("fk_bus_gateway_document_document_id");
+
+                    b.Navigation("DataSource");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGatewayRoute", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Gateway.BusGateway", "BusGateway")
+                        .WithMany("Routes")
+                        .HasForeignKey("BusGatewayId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired()
+                        .HasConstraintName("fk_bus_gateway_route_bus_gateway_bus_gateway_id");
+
+                    b.HasOne("SW.Bitween.Domain.Partner", "Partner")
+                        .WithMany()
+                        .HasForeignKey("PartnerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("fk_bus_gateway_route_partner_partner_id");
+
+                    b.HasOne("SW.Bitween.Domain.Subscription", "Subscription")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired()
+                        .HasConstraintName("fk_bus_gateway_route_subscription_subscription_id");
+
+                    b.Navigation("BusGateway");
+
+                    b.Navigation("Partner");
+
+                    b.Navigation("Subscription");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Partner", b =>
+                {
+                    b.OwnsMany("SW.Bitween.Domain.ApiCredential", "ApiCredentials", b1 =>
+                        {
+                            b1.Property<int>("PartnerId")
+                                .HasColumnType("integer")
+                                .HasColumnName("partner_id");
+
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("integer")
+                                .HasColumnName("id");
+
+                            NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b1.Property<int>("Id"));
+
+                            b1.Property<string>("Key")
+                                .IsRequired()
+                                .HasMaxLength(500)
+                                .HasColumnType("character varying(500)")
+                                .HasColumnName("key");
+
+                            b1.Property<string>("Name")
+                                .IsRequired()
+                                .HasMaxLength(500)
+                                .HasColumnType("character varying(500)")
+                                .HasColumnName("name");
+
+                            b1.HasKey("PartnerId", "Id")
+                                .HasName("pk_partner_api_credential");
+
+                            b1.HasIndex("Key")
+                                .IsUnique()
+                                .HasDatabaseName("ix_partner_api_credential_key");
+
+                            b1.ToTable("partner_api_credential", "infolink");
+
+                            b1.WithOwner()
+                                .HasForeignKey("PartnerId")
+                                .HasConstraintName("fk_partner_api_credential_partner_partner_id");
+
+                            b1.HasData(
+                                new
+                                {
+                                    PartnerId = 1,
+                                    Id = 1,
+                                    Key = "7facc758283844b49cc4ffd26a75b1de",
+                                    Name = "default"
+                                });
+                        });
+
+                    b.Navigation("ApiCredentials");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Subscription", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Subscription", null)
+                        .WithMany()
+                        .HasForeignKey("AggregationForId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("fk_subscription_aggregation_for");
+
+                    b.HasOne("SW.Bitween.Domain.SubscriptionCategory", "Category")
+                        .WithMany()
+                        .HasForeignKey("CategoryId")
+                        .HasConstraintName("fk_subscription_subscription_category_category_id");
+
+                    b.HasOne("SW.Bitween.Domain.DataSources.DataSource", null)
+                        .WithMany()
+                        .HasForeignKey("DataSourceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("fk_subscription_data_source_data_source_id");
+
+                    b.HasOne("SW.Bitween.Domain.Document", null)
+                        .WithMany()
+                        .HasForeignKey("DocumentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired()
+                        .HasConstraintName("fk_subscription_document_document_id");
+
+                    b.HasOne("SW.Bitween.Domain.Partner", null)
+                        .WithMany("Subscriptions")
+                        .HasForeignKey("PartnerId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("fk_subscription_partner_partner_id");
+
+                    b.HasOne("SW.Bitween.Domain.Subscription", null)
+                        .WithMany()
+                        .HasForeignKey("ResponseSubscriptionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("fk_subscription_response_subscriber");
+
+                    b.HasOne("SW.Bitween.Domain.RetryPolicy", "RetryPolicy")
+                        .WithMany()
+                        .HasForeignKey("RetryPolicyId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("fk_subscription_retry_policy_retry_policy_id");
+
+                    b.HasOne("SW.Bitween.Domain.WorkGroup", "WorkGroup")
+                        .WithMany()
+                        .HasForeignKey("WorkGroupId")
+                        .HasConstraintName("fk_subscription_work_group_work_group_id");
+
+                    b.OwnsMany("SW.Bitween.Domain.Schedule", "Schedules", b1 =>
+                        {
+                            b1.Property<int>("SubscriptionId")
+                                .HasColumnType("integer")
+                                .HasColumnName("subscription_id");
+
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("integer")
+                                .HasColumnName("id");
+
+                            NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b1.Property<int>("Id"));
+
+                            b1.Property<bool>("Backwards")
+                                .HasColumnType("boolean")
+                                .HasColumnName("backwards");
+
+                            b1.Property<long>("On")
+                                .HasColumnType("bigint")
+                                .HasColumnName("on");
+
+                            b1.Property<byte>("Recurrence")
+                                .HasColumnType("smallint")
+                                .HasColumnName("recurrence");
+
+                            b1.HasKey("SubscriptionId", "Id")
+                                .HasName("pk_subscription_schedule");
+
+                            b1.ToTable("subscription_schedule", "infolink");
+
+                            b1.WithOwner()
+                                .HasForeignKey("SubscriptionId")
+                                .HasConstraintName("fk_subscription_schedule_subscription_subscription_id");
+                        });
+
+                    b.Navigation("Category");
+
+                    b.Navigation("RetryPolicy");
+
+                    b.Navigation("Schedules");
+
+                    b.Navigation("WorkGroup");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Xchange", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Document", null)
+                        .WithMany()
+                        .HasForeignKey("DocumentId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired()
+                        .HasConstraintName("fk_xchange_document_document_id");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeAggregation", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangeAggregation", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_xchange_aggregation_xchange_id");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeDelivery", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangeDelivery", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_xchange_delivery_xchange_id");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangePromotedProperties", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangePromotedProperties", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_xchange_promoted_properties_xchange_id");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.XchangeResult", b =>
+                {
+                    b.HasOne("SW.Bitween.Domain.Xchange", null)
+                        .WithOne()
+                        .HasForeignKey("SW.Bitween.Domain.XchangeResult", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_xchange_result_xchange_id");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzBlobTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("BlobTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_qrtz_blob_triggers_qrtz_triggers_sched_name_trigger_name_tr");
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzCronTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("CronTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_qrtz_cron_triggers_qrtz_triggers_sched_name_trigger_name_tr");
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimplePropertyTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("SimplePropertyTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_qrtz_simprop_triggers_qrtz_triggers_sched_name_trigger_name");
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzSimpleTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzTrigger", "Trigger")
+                        .WithMany("SimpleTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_qrtz_simple_triggers_qrtz_triggers_sched_name_trigger_name_");
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzTrigger", b =>
+                {
+                    b.HasOne("SW.Scheduler.QuartzJobDetail", "JobDetail")
+                        .WithMany("Triggers")
+                        .HasForeignKey("SchedulerName", "JobName", "JobGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_qrtz_triggers_qrtz_job_details_sched_name_job_name_job_group");
+
+                    b.Navigation("JobDetail");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.ApiGateway", b =>
+                {
+                    b.Navigation("Partners");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Gateway.BusGateway", b =>
+                {
+                    b.Navigation("Routes");
+                });
+
+            modelBuilder.Entity("SW.Bitween.Domain.Partner", b =>
+                {
+                    b.Navigation("Subscriptions");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzJobDetail", b =>
+                {
+                    b.Navigation("Triggers");
+                });
+
+            modelBuilder.Entity("SW.Scheduler.QuartzTrigger", b =>
+                {
+                    b.Navigation("BlobTriggers");
+
+                    b.Navigation("CronTriggers");
+
+                    b.Navigation("SimplePropertyTriggers");
+
+                    b.Navigation("SimpleTriggers");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/SW.Bitween.PgSql/Migrations/20260915090259_AddMustChangePassword.cs b/SW.Bitween.PgSql/Migrations/20260915090259_AddMustChangePassword.cs
new file mode 100644
index 00000000..bf2ae303
--- /dev/null
+++ b/SW.Bitween.PgSql/Migrations/20260915090259_AddMustChangePassword.cs
@@ -0,0 +1,48 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace SW.Bitween.PgSql.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddMustChangePassword : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "must_change_password",
+                schema: "infolink",
+                table: "Accounts",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+
+            // Only where the password is still the one we ship.
+            //
+            // EF scaffolded a plain UpdateData here, because as far as the model is concerned the
+            // seeded row simply gained a column value. That would have demanded a new password from
+            // every installation on the next deploy, including the ones that chose theirs years ago
+            // — a forced interruption for people who had already done the right thing.
+            //
+            // Matching on the stored hash narrows it to the installations the flag is actually for:
+            // those still signing in with the password published in our public repository. On
+            // anything else this updates no rows at all.
+            migrationBuilder.Sql(
+                """
+                UPDATE infolink."Accounts"
+                SET must_change_password = TRUE
+                WHERE id = 9999 AND password = '$SWHASH$V1$10000$VQCi48eitH4Ml5juvBMOFZrMdQwBbhuIQVXe6RR7qJdDF2bJ';
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "must_change_password",
+                schema: "infolink",
+                table: "Accounts");
+        }
+    }
+}
diff --git a/SW.Bitween.PgSql/Migrations/BitweenDbContextModelSnapshot.cs b/SW.Bitween.PgSql/Migrations/BitweenDbContextModelSnapshot.cs
index 2ad7499e..638f1dc8 100644
--- a/SW.Bitween.PgSql/Migrations/BitweenDbContextModelSnapshot.cs
+++ b/SW.Bitween.PgSql/Migrations/BitweenDbContextModelSnapshot.cs
@@ -87,6 +87,10 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("timestamp with time zone")
                         .HasColumnName("modified_on");
 
+                    b.Property<bool>("MustChangePassword")
+                        .HasColumnType("boolean")
+                        .HasColumnName("must_change_password");
+
                     b.Property<string>("Password")
                         .HasMaxLength(500)
                         .IsUnicode(false)
@@ -118,6 +122,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                             EmailProvider = (byte)0,
                             FailedLoginCount = 0,
                             LoginMethods = (byte)2,
+                            MustChangePassword = true,
                             Password = "$SWHASH$V1$10000$VQCi48eitH4Ml5juvBMOFZrMdQwBbhuIQVXe6RR7qJdDF2bJ",
                             Role = 0
                         });
diff --git a/SW.Bitween.Sdk/Model/Account.cs b/SW.Bitween.Sdk/Model/Account.cs
index 824b6e13..e819d272 100644
--- a/SW.Bitween.Sdk/Model/Account.cs
+++ b/SW.Bitween.Sdk/Model/Account.cs
@@ -74,6 +74,14 @@ public class AccountModel
 public class ProfileModel : AccountModel
 {
     public List<string> Permissions { get; set; } = [];
+
+    /// <summary>
+    /// The account still has the password it was created with, so its token grants nothing until
+    /// that is changed. Here as well as on the sign-in response because a reload has no sign-in
+    /// response to read — without it, refreshing the page lands on an app with every screen denied
+    /// and no explanation.
+    /// </summary>
+    public bool MustChangePassword { get; set; }
 }
 
 public class UnlockAccountModel
diff --git a/SW.Bitween.Web/ClientApp/src/api/http/session.ts b/SW.Bitween.Web/ClientApp/src/api/http/session.ts
index 7c4c4378..4a50bdb2 100644
--- a/SW.Bitween.Web/ClientApp/src/api/http/session.ts
+++ b/SW.Bitween.Web/ClientApp/src/api/http/session.ts
@@ -13,6 +13,7 @@ interface Profile {
   createdOn: string;
   roles: { id: number; name: string }[] | null;
   permissions: string[] | null;
+  mustChangePassword?: boolean;
 }
 
 /** POST /accounts/login → { jwt }. */
@@ -37,6 +38,7 @@ const buildSession = (profile: Profile): Session => {
     roles: (profile.roles ?? []).map((r) => ({ id: String(r.id), name: r.name })),
     // Resolved server-side from the user's roles, so a revoked role takes effect on next load.
     permissions: profile.permissions ?? [],
+    mustChangePassword: profile.mustChangePassword ?? false,
   };
 };
 
diff --git a/SW.Bitween.Web/ClientApp/src/api/types.ts b/SW.Bitween.Web/ClientApp/src/api/types.ts
index 1181eebe..1c210fe7 100644
--- a/SW.Bitween.Web/ClientApp/src/api/types.ts
+++ b/SW.Bitween.Web/ClientApp/src/api/types.ts
@@ -61,6 +61,12 @@ export interface Session {
   roles: RoleSummary[];
   /** The union of every permission the user's roles grant — resolved by the backend. */
   permissions: PermissionKey[];
+  /**
+   * The account still has the password it was created with. The backend grants such a token
+   * nothing, so `permissions` is empty and every screen would refuse — the app sends them to
+   * change it instead of leaving them staring at an empty shell.
+   */
+  mustChangePassword: boolean;
 }
 
 export interface ApiError {
diff --git a/SW.Bitween.Web/ClientApp/src/auth/guards.tsx b/SW.Bitween.Web/ClientApp/src/auth/guards.tsx
index d87db0e2..7136a2f7 100644
--- a/SW.Bitween.Web/ClientApp/src/auth/guards.tsx
+++ b/SW.Bitween.Web/ClientApp/src/auth/guards.tsx
@@ -20,6 +20,11 @@ export function RequireAuth() {
   if (!session) {
     return <Navigate to="/login" state={{ from: location.pathname + location.search }} replace />;
   }
+  // An account whose password nobody chose holds a token that grants nothing, so every screen
+  // past here would refuse it one at a time. Sent to the one screen that can end that instead.
+  if (session.mustChangePassword && location.pathname !== "/change-password") {
+    return <Navigate to="/change-password" replace />;
+  }
   return <Outlet />;
 }
 
diff --git a/SW.Bitween.Web/ClientApp/src/pages/auth/ChangePassword.tsx b/SW.Bitween.Web/ClientApp/src/pages/auth/ChangePassword.tsx
new file mode 100644
index 00000000..b10e1e26
--- /dev/null
+++ b/SW.Bitween.Web/ClientApp/src/pages/auth/ChangePassword.tsx
@@ -0,0 +1,102 @@
+import { useState, type FormEvent } from "react";
+import { useMutation } from "@tanstack/react-query";
+import { api } from "../../api";
+import { useSession } from "../../auth/SessionContext";
+import { validatePassword } from "../../lib/passwordPolicy";
+import { Button, FormError } from "../../components/ui/basics";
+import { Field, PasswordInput } from "../../components/ui/forms";
+import { AuthLayout } from "./AuthLayout";
+
+/**
+ * The one screen an account with an unchanged password can reach.
+ *
+ * Every installation is seeded with the same administrator, whose password is published in our
+ * public repository — so on any installation where nobody changed it, that account was open to
+ * anyone who had read the repository. The backend now issues such an account a token that grants
+ * nothing at all, which closes the hole but leaves a person signed in to an application where
+ * every screen refuses. This is where they are sent instead, and changing the password is what
+ * lets them out of it.
+ */
+export function ChangePasswordPage() {
+  const { refresh } = useSession();
+
+  const [currentPassword, setCurrentPassword] = useState("");
+  const [newPassword, setNewPassword] = useState("");
+  const [confirmPassword, setConfirmPassword] = useState("");
+  const [error, setError] = useState("");
+
+  const change = useMutation({
+    mutationFn: () => api.changePassword(currentPassword, newPassword),
+    // The flag lives on the account, so re-reading the session is what clears this screen:
+    // the next profile read comes back without it and the guard stops redirecting here.
+    onSuccess: () => refresh(),
+  });
+
+  const submit = (e: FormEvent) => {
+    e.preventDefault();
+    setError("");
+
+    if (newPassword !== confirmPassword) {
+      setError("The new passwords don't match.");
+      return;
+    }
+    if (newPassword === currentPassword) {
+      setError("Choose a password different from the current one.");
+      return;
+    }
+    // The server rejects a weak password too; checking here saves the round trip.
+    const problems = validatePassword(newPassword);
+    if (problems.length > 0) {
+      setError(problems.join(" "));
+      return;
+    }
+    change.mutate();
+  };
+
+  return (
+    <AuthLayout>
+      <h1 className="text-2xl font-semibold tracking-tight text-ink-900">Choose a password</h1>
+      <p className="mt-1.5 text-sm text-ink-500">
+        This account still has the password it shipped with, which is publicly known. Pick your own
+        to carry on — nothing else is available until you do.
+      </p>
+
+      <form onSubmit={submit} className="mt-7 space-y-4">
+        <Field label="Current password" htmlFor="current-password">
+          <PasswordInput
+            id="current-password"
+            autoComplete="current-password"
+            value={currentPassword}
+            onChange={(e) => setCurrentPassword(e.target.value)}
+            required
+          />
+        </Field>
+        <Field label="New password" htmlFor="new-password">
+          <PasswordInput
+            id="new-password"
+            autoComplete="new-password"
+            value={newPassword}
+            onChange={(e) => setNewPassword(e.target.value)}
+            required
+          />
+        </Field>
+        <Field label="Confirm new password" htmlFor="confirm-password">
+          <PasswordInput
+            id="confirm-password"
+            autoComplete="new-password"
+            value={confirmPassword}
+            onChange={(e) => setConfirmPassword(e.target.value)}
+            required
+          />
+        </Field>
+
+        {error && <FormError>{error}</FormError>}
+        {change.isError && <FormError>{(change.error as Error).message}</FormError>}
+
+        <Button type="submit" className="w-full" disabled={change.isPending}>
+          {change.isPending ? "Saving…" : "Set password"}
+        </Button>
+      </form>
+    </AuthLayout>
+  );
+}
diff --git a/SW.Bitween.Web/ClientApp/src/router.tsx b/SW.Bitween.Web/ClientApp/src/router.tsx
index 6a487179..fb2c954c 100644
--- a/SW.Bitween.Web/ClientApp/src/router.tsx
+++ b/SW.Bitween.Web/ClientApp/src/router.tsx
@@ -4,6 +4,7 @@ import { useSession } from "./auth/SessionContext";
 import { AppShell } from "./components/layout/AppShell";
 import { NAV_GROUPS, homePath } from "./nav";
 import { LoginPage } from "./pages/auth/Login";
+import { ChangePasswordPage } from "./pages/auth/ChangePassword";
 import { NotFoundPage, PlaceholderPage } from "./pages/PlaceholderPage";
 import { ProfilePage } from "./pages/ProfilePage";
 import { AuditPage } from "./pages/audit/AuditPage";
@@ -77,6 +78,9 @@ export const router = createBrowserRouter([
   {
     element: <RequireAuth />,
     children: [
+      // Inside the auth guard because it needs a session, outside the shell because the session
+      // it serves grants nothing — a sidebar built from those permissions would be empty.
+      { path: "change-password", element: <ChangePasswordPage /> },
       {
         element: <AppShell />,
         children: [

From c5af30ce1d89b837484f5062965b575581a72b26 Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:10:12 +0300
Subject: [PATCH 06/12] fix: remove the break-glass login

POST /login signed in against a credential held in configuration, which
defaulted to a username and password published in our public repository.
Neither UI ever called it; a penetration test did.

The e2e harness used it to recover an admin that had lost its last role,
so that fallback goes too.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 SW.Bitween.Api/Resources/Login/Login.cs       | 46 -------------------
 .../Fixtures/BitweenFixture.cs                |  1 -
 SW.Bitween.Web/ClientApp/e2e/global-setup.ts  | 35 +++++++++-----
 3 files changed, 23 insertions(+), 59 deletions(-)
 delete mode 100644 SW.Bitween.Api/Resources/Login/Login.cs

diff --git a/SW.Bitween.Api/Resources/Login/Login.cs b/SW.Bitween.Api/Resources/Login/Login.cs
deleted file mode 100644
index c4d75b80..00000000
--- a/SW.Bitween.Api/Resources/Login/Login.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Security.Claims;
-using System.Threading.Tasks;
-using SW.HttpExtensions;
-using SW.Bitween.Model;
-using SW.PrimitiveTypes;
-
-namespace SW.Bitween.Resources.Login
-{
-    [Unprotect]
-    public class Login(BitweenDbContext dbContext, BitweenOptions BitweenSettings,
-        JwtTokenParameters jwtTokenParameters) : ICommandHandler<UserLogin,object>
-    {
-        private readonly BitweenDbContext dbContext = dbContext;
-        private readonly BitweenOptions BitweenSettings = BitweenSettings;
-        private readonly JwtTokenParameters jwtTokenParameters = jwtTokenParameters;
-
-        public Task<object> Handle(UserLogin request)
-        {
-
-            var cred = BitweenSettings.AdminCredentials.Split(":");
-
-            if (cred[0].Equals(request.Username, StringComparison.OrdinalIgnoreCase))
-            {
-                if (cred[1].Equals(request.Password))
-                {
-                    // No account backs these configured credentials, so there are no roles to
-                    // resolve — grant everything explicitly rather than relying on a guard that
-                    // fails open on a missing claim.
-                    var claims = new List<Claim>
-                    {
-                        new Claim(ClaimTypes.Name, cred[0]),
-                        new Claim(RequestContextExtensions.SuperuserClaim, "true"),
-                    };
-
-                    return Task.FromResult<object>(new
-                    {
-                        Jwt = jwtTokenParameters.WriteJwt(new ClaimsIdentity(claims))
-                    });
-                }
-            }
-            throw new SWUnauthorizedException();
-        }
-    }
-}
\ No newline at end of file
diff --git a/SW.Bitween.IntegrationTests/Fixtures/BitweenFixture.cs b/SW.Bitween.IntegrationTests/Fixtures/BitweenFixture.cs
index ffd74b51..f01a1ff1 100644
--- a/SW.Bitween.IntegrationTests/Fixtures/BitweenFixture.cs
+++ b/SW.Bitween.IntegrationTests/Fixtures/BitweenFixture.cs
@@ -179,7 +179,6 @@ await Task.WhenAll(_postgres.StartAsync(), _rabbitMq.StartAsync(), _mailHog.Star
                         StorageProvider = "LocalTests",
                         DatabaseType = "PgSql",
                         BusDefaultQueuePrefetch = 10,
-                        AdminCredentials = "configured-admin:configured-password",
                         JwtExpiryMinutes = 30,
                         // A passphrase has to exist or secret settings refuse to be stored at
                         // all, which would make the encryption path untestable.
diff --git a/SW.Bitween.Web/ClientApp/e2e/global-setup.ts b/SW.Bitween.Web/ClientApp/e2e/global-setup.ts
index 9fd7aa44..a0d36b87 100644
--- a/SW.Bitween.Web/ClientApp/e2e/global-setup.ts
+++ b/SW.Bitween.Web/ClientApp/e2e/global-setup.ts
@@ -12,8 +12,6 @@ import { request } from "@playwright/test";
 const API = "https://localhost:7155/api";
 const ADMIN_EMAIL = "admin@Bitween.systems";
 const ADMIN_PASSWORD = "Mtm@dmin!2";
-/** Configured break-glass credentials — the only way in when the admin has no roles left. */
-const BREAK_GLASS = { username: "1", password: "1" };
 const ADMINISTRATOR_ROLE_ID = 1;
 
 const TEST_EMAIL = /^pw-.*@example\.test$/;
@@ -50,23 +48,36 @@ interface Account {
 export default async function purgeTestData() {
   const api = await request.newContext({ ignoreHTTPSErrors: true });
 
-  // Prefer the real admin; fall back to break-glass, which works even with no roles at all.
   const login = await api.post(`${API}/accounts/login`, {
     data: { Username: ADMIN_EMAIL, Password: ADMIN_PASSWORD },
   });
-  let token: string = login.ok() ? (await login.json()).jwt : "";
+  const token: string = login.ok() ? (await login.json()).jwt : "";
 
   const auth = () => ({ Authorization: `Bearer ${token}` });
-  let accounts = await api.get(`${API}/accounts?limit=500`, { headers: auth() });
+
+  // The seeded admin ships with a published password, so a freshly migrated database flags it and
+  // issues it a token that grants nothing until someone chooses a new one. Setting it back to the
+  // same value clears the flag, which is the whole of what the suite needs: every spec signs in as
+  // this account, and none of them is about the forced change itself.
+  //
+  // Deliberately loud about what it is. Re-setting a known password is exactly the thing the flag
+  // exists to prevent — it is defensible here only because this database exists to be thrown away.
+  await api.post(`${API}/accounts/changePassword`, {
+    headers: auth(),
+    data: { OldPassword: ADMIN_PASSWORD, NewPassword: ADMIN_PASSWORD },
+  });
+
+  const accounts = await api.get(`${API}/accounts?limit=500`, { headers: auth() });
 
   if (!accounts.ok()) {
-    const su = await api.post(`${API}/login`, { data: BREAK_GLASS });
-    if (!su.ok())
-      throw new Error(
-        "Can't reach the API as an administrator or via break-glass — is the local backend running?",
-      );
-    token = (await su.json()).jwt;
-    accounts = await api.get(`${API}/accounts?limit=500`, { headers: auth() });
+    // There used to be a fallback here: a second sign-in against credentials held in
+    // configuration, which worked even for an admin holding no roles. That endpoint shipped with a
+    // published default password and has been removed, so this is now the only way in — and if the
+    // seeded admin has lost Administrator, no request can put it back.
+    throw new Error(
+      "Can't reach the API as the seeded administrator. Either the local backend isn't running, " +
+        "or the admin has lost its Administrator role and the database needs restoring.",
+    );
   }
 
   const rows: Account[] = (await accounts.json()).result ?? [];

From f9499f8bee204e8393f4702dfe37f5112614b058 Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:10:22 +0300
Subject: [PATCH 07/12] fix: refuse the sample signing key, rate limit, and
 close the API docs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The sample key ships as the chart default and is public, so a token can
be minted by anyone; the app now refuses to start on it in every
environment. Not exempting Development on purpose — the chart also
defaults ASPNETCORE_ENVIRONMENT to Development, so that exemption would
have covered exactly the deployments nobody had configured.

API docs move behind Bitween:ExposeApiDocs, off by default, for the same
reason. Rate limiting is 10 sign-ins a minute per address and 600 other
requests a minute per account.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 SW.Bitween.Api/Services/BitweenOptions.cs |  18 ++-
 SW.Bitween.Web/Startup.cs                 | 148 +++++++++++++++++++++-
 2 files changed, 163 insertions(+), 3 deletions(-)

diff --git a/SW.Bitween.Api/Services/BitweenOptions.cs b/SW.Bitween.Api/Services/BitweenOptions.cs
index 8540418e..1f8484dc 100644
--- a/SW.Bitween.Api/Services/BitweenOptions.cs
+++ b/SW.Bitween.Api/Services/BitweenOptions.cs
@@ -10,7 +10,6 @@ public BitweenOptions()
         {
             //   AESEncryptionKey = "BitweenS9SecretKey";
             AdapterPath = "adapters";
-            AdminCredentials = "admin:1234512345";
             DocumentPrefix = "temp30/Bitweendocs";
             DatabaseType = "MySql";
             AdminDatabaseName = "defaultdb";
@@ -36,7 +35,22 @@ public BitweenOptions()
         /// (<c>{AdapterPath}/{adapterId}</c>). Passed to <c>ServerlessOptions.AdapterRemotePath</c>.
         /// </summary>
         public string AdapterPath { get; set; }
-        public string AdminCredentials { get; set; }
+
+        /// <summary>
+        /// Serves the API description and the Swagger interface. Off unless switched on.
+        /// </summary>
+        /// <remarks>
+        /// A penetration test read all 94 endpoints and their request and response shapes off a
+        /// deployed instance without signing in, and used the repository link it found alongside
+        /// them to reach our published source. Useful while building, an inventory for a stranger
+        /// anywhere else.
+        /// <para>
+        /// A setting of its own rather than a Development-only behaviour: the deployment chart
+        /// defaults ASPNETCORE_ENVIRONMENT to Development, so keying this to the environment would
+        /// have left it on for exactly the deployments nobody had configured.
+        /// </para>
+        /// </remarks>
+        public bool ExposeApiDocs { get; set; }
         public string DocumentPrefix { get; set; }
         public int ServerlessCommandTimeout { get; set; }
 
diff --git a/SW.Bitween.Web/Startup.cs b/SW.Bitween.Web/Startup.cs
index ded1b37c..017b838b 100644
--- a/SW.Bitween.Web/Startup.cs
+++ b/SW.Bitween.Web/Startup.cs
@@ -1,11 +1,14 @@
 using System;
 using System.IO.Compression;
 using System.Linq;
+using System.Security.Claims;
 using System.Text;
+using System.Threading.RateLimiting;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.RateLimiting;
 using Microsoft.AspNetCore.ResponseCompression;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
@@ -367,6 +370,8 @@ public void ConfigureServices(IServiceCollection services)
             // {
             //     config.DefaultApiClientFactory = sp => sp.GetService<BitweenClient>();
             // });
+            RejectSampleSigningKey();
+            AddRateLimiting(services);
             services.AddJwtTokenParameters();
             services.AddAuthorization();
             services.AddScoped<RunFlagUpdater>();
@@ -507,11 +512,148 @@ private static void WarnIfMsalRedirectUriIsStale(IApplicationBuilder app)
                 redirectUri.Length == 0 ? "(not set)" : redirectUri, MsalRedirectPath);
         }
 
+        /// <summary>
+        /// The signing key every token is minted and verified with. Anyone holding it can mint a
+        /// token for any identity, including one that has no account, so the one value that must
+        /// never be shared between deployments is this one.
+        /// </summary>
+        /// <remarks>
+        /// The sample below ships as the default in our public deployment chart, which is exactly
+        /// why it has to be rejected: a deployment that never overrode it looked completely healthy
+        /// — tokens were issued, signatures verified — while anyone who had read the chart could
+        /// mint their own. A penetration test did precisely that.
+        /// <para>
+        /// Checked in every environment, deliberately. Exempting Development would have made this
+        /// inert exactly where it is needed most: the chart also defaults ASPNETCORE_ENVIRONMENT to
+        /// Development, so the deployments most likely to be running an untouched chart are the
+        /// ones that would have skipped the check. Local development uses its own key instead,
+        /// which is what the settings files carry.
+        /// </para>
+        /// <para>
+        /// Refusing to start is the point. There is no degraded mode worth offering: running on a
+        /// public key is indistinguishable, from the inside, from having no authentication at all.
+        /// </para>
+        /// </remarks>
+        private const string SampleSigningKey = "6547647654764764767657658658758765876532542";
+
+        private void RejectSampleSigningKey()
+        {
+            var key = Configuration["Token:Key"];
+
+            if (string.IsNullOrWhiteSpace(key))
+                throw new InvalidOperationException(
+                    "Token:Key is not configured. Generate a random secret unique to this " +
+                    "deployment — tokens cannot be trusted without one.");
+
+            if (key == SampleSigningKey)
+                throw new InvalidOperationException(
+                    "Token:Key is still the sample value that ships as the default in the " +
+                    "deployment chart, and it is published in a public repository — anyone can " +
+                    "mint a valid token with it. Set Token:Key (env: Token__Key) to a random " +
+                    "secret unique to this deployment. Doing so signs out everyone holding a " +
+                    "token issued under the old key, which is the intended outcome.");
+        }
+
+        /// <summary>
+        /// One limit over the whole application, rather than an attribute remembered endpoint by
+        /// endpoint.
+        /// </summary>
+        /// <remarks>
+        /// A penetration test ran forty-six passwords at the login endpoint in a single
+        /// uninterrupted burst; nothing throttled, delayed or blocked any of them, and response
+        /// times stayed flat throughout. Nothing else in the API behaved differently — the whole
+        /// dataset could be pulled as fast as it could be asked for.
+        /// <para>
+        /// Partitioned by account where there is one and by address otherwise. Partitioning
+        /// everything by address would have made one office behind a single NAT share one budget,
+        /// which turns a busy afternoon into an outage; partitioning by account cannot work before
+        /// anyone has signed in, which is exactly where the strict limit is needed. Address is read
+        /// after <c>UseForwardedHeaders</c>, so it is the client rather than the ingress.
+        /// </para>
+        /// <para>
+        /// Sign-in is deliberately far tighter than everything else. Ten attempts a minute is more
+        /// than any person needs and nowhere near enough to work through a password list. It is not
+        /// a replacement for the per-account lockout, which counts attempts against one account
+        /// across every address; this counts them per address across every account.
+        /// </para>
+        /// </remarks>
+        private static void AddRateLimiting(IServiceCollection services)
+        {
+            services.AddRateLimiter(options =>
+            {
+                options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
+
+                options.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, string>(context =>
+                {
+                    if (IsSignInPath(context.Request.Path))
+                        return RateLimitPartition.GetFixedWindowLimiter(
+                            $"signin:{ClientAddress(context)}",
+                            _ => new FixedWindowRateLimiterOptions
+                            {
+                                PermitLimit = 10,
+                                Window = TimeSpan.FromMinutes(1)
+                            });
+
+                    var account = context.User?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
+
+                    return RateLimitPartition.GetFixedWindowLimiter(
+                        account is null ? $"anon:{ClientAddress(context)}" : $"account:{account}",
+                        _ => new FixedWindowRateLimiterOptions
+                        {
+                            PermitLimit = 600,
+                            Window = TimeSpan.FromMinutes(1)
+                        });
+                });
+            });
+        }
+
+        /// <summary>
+        /// Matched on the trailing segment so that a sign-in route added later is covered the day
+        /// it appears rather than the day someone remembers this list.
+        /// </summary>
+        /// <remarks>
+        /// Narrowed to the API prefix because the SPA has a <c>/login</c> route of its own, served
+        /// through the fallback further down this pipeline. Without that, reloading the sign-in
+        /// page ten times would spend the whole sign-in budget on page loads and lock someone out
+        /// of an app they had not yet tried to enter.
+        /// </remarks>
+        private static bool IsSignInPath(PathString path) =>
+            path.HasValue
+            && path.Value!.StartsWith("/api/", StringComparison.OrdinalIgnoreCase)
+            && path.Value!.EndsWith("/login", StringComparison.OrdinalIgnoreCase);
+
+        private static string ClientAddress(HttpContext context) =>
+            context.Connection.RemoteIpAddress?.ToString() ?? "unknown";
+
         public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
         {
+            var apiDocsExposed = app.ApplicationServices.GetRequiredService<BitweenOptions>().ExposeApiDocs;
+
             app.UseSWConsoleLogger();
             WarnIfMsalRedirectUriIsStale(app);
             app.UseForwardedHeaders();
+
+            // The API description is a map of the whole surface — every route, every request and
+            // response shape — and nobody who should have it needs to fetch it from a running
+            // deployment. Closed here, ahead of everything else, because the two halves are served
+            // by different things: the UI page below, and /api/swagger.json by CqApi itself, which
+            // offers no switch of its own. One gate covers both.
+            if (!apiDocsExposed)
+            {
+                app.Use(async (context, next) =>
+                {
+                    var path = context.Request.Path;
+                    if (path.StartsWithSegments("/swagger") ||
+                        path.Equals("/api/swagger.json", StringComparison.OrdinalIgnoreCase))
+                    {
+                        context.Response.StatusCode = StatusCodes.Status404NotFound;
+                        return;
+                    }
+
+                    await next();
+                });
+            }
+
             // Early, so everything downstream — static files, the SPA fallback, every API
             // response — is compressed on the way out.
             app.UseResponseCompression();
@@ -601,11 +743,15 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
             app.UseStaticFiles();
             app.UseRouting();
             app.UseAuthentication();
+            // After authentication, so an authenticated request is counted against its account
+            // rather than against whatever address it shares with everyone else in the building.
+            app.UseRateLimiter();
             app.UseAuthorization();
             app.UseHttpAsRequestContext();
             SW.Logger.Console.IAppBuilderExtensions.UseRequestContextLogEnricher(app);
 
-            app.UseSwaggerUI(c => { c.SwaggerEndpoint("/api/swagger.json", "Bitween Api"); });
+            if (apiDocsExposed)
+                app.UseSwaggerUI(c => { c.SwaggerEndpoint("/api/swagger.json", "Bitween Api"); });
 
 
             app.UseEndpoints(endpoints =>

From f4e935121f8cca1c1c5d685aeaf5858e0c8f996e Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:10:22 +0300
Subject: [PATCH 08/12] test: cover the penetration test findings

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../Tests/PentestFindingTests.cs              | 215 ++++++++++++++++++
 1 file changed, 215 insertions(+)
 create mode 100644 SW.Bitween.IntegrationTests/Tests/PentestFindingTests.cs

diff --git a/SW.Bitween.IntegrationTests/Tests/PentestFindingTests.cs b/SW.Bitween.IntegrationTests/Tests/PentestFindingTests.cs
new file mode 100644
index 00000000..4e082d35
--- /dev/null
+++ b/SW.Bitween.IntegrationTests/Tests/PentestFindingTests.cs
@@ -0,0 +1,215 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using SW.Bitween.Domain;
+using SW.Bitween.Domain.Accounts;
+using SW.Bitween.IntegrationTests.Fixtures;
+using SW.Bitween.Model;
+using SW.Bitween.Services;
+using SW.PrimitiveTypes;
+using Xunit;
+
+namespace SW.Bitween.IntegrationTests.Tests;
+
+/// <summary>
+/// The findings a penetration test raised against a deployed instance, each pinned by the thing
+/// that would have to stop being true for it to come back.
+/// </summary>
+/// <remarks>
+/// Grouped by what they have in common rather than split across the handlers they touch: every one
+/// of them is a value leaving the system that should not, and none is visible from reading the
+/// handler alone — a leaked credential looks exactly like a populated field, and a missing rate
+/// limit looks exactly like a fast API. Tests are the only place that distinction is written down.
+/// </remarks>
+[Collection("Bitween")]
+public class PentestFindingTests(BitweenFixture fixture)
+{
+    /// <summary>
+    /// GIG.WEB-003. The list endpoint returned every integration's adapter properties in cleartext
+    /// — storage keys, an OAuth secret, partner passwords — to anyone allowed to see the list.
+    /// </summary>
+    [Fact]
+    public async Task Subscription_list_withholds_adapter_properties()
+    {
+        await using var scope = fixture.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<BitweenDbContext>();
+        scope.Superuser();
+
+        var doc = new Document(null, "Pentest Secret Doc", DocumentFormat.Json);
+        db.Set<Document>().Add(doc);
+        await db.SaveChangesAsync();
+
+        var sub = new Subscription("Pentest Secret Sub", doc.Id);
+        sub.SetDictionaries(
+            handler: new Dictionary<string, string> { ["AzureAccessKey"] = "the-storage-key" },
+            mapper: new Dictionary<string, string> { ["ClientSecret"] = "the-oauth-secret" },
+            receiver: new Dictionary<string, string> { ["Password"] = "the-partner-password" },
+            document: new Dictionary<string, string>(),
+            validator: new Dictionary<string, string> { ["Token"] = "the-validator-token" });
+        db.Set<Subscription>().Add(sub);
+        await db.SaveChangesAsync();
+
+        var handler = ActivatorUtilities.CreateInstance<Resources.Subscriptions.Search>(scope.ServiceProvider);
+        var response = (SearchyResponse<SubscriptionSearch>)await handler.Handle(
+            new SearchyRequest { PageSize = 500 });
+
+        var row = Assert.Single(response.Result.Where(r => r.Id == sub.Id));
+        Assert.Empty(row.HandlerProperties);
+        Assert.Empty(row.MapperProperties);
+        Assert.Empty(row.ReceiverProperties);
+        Assert.Empty(row.ValidatorProperties);
+    }
+
+    /// <summary>
+    /// The filter that searches inside property values still works, which is the whole reason the
+    /// properties are loaded and then dropped rather than left out of the query.
+    /// </summary>
+    /// <remarks>
+    /// Paired with the test above on purpose: the obvious way to stop leaking the properties is to
+    /// stop selecting them, and that would silently break this search instead. Together they say
+    /// "loaded, used, withheld" — remove either and one of them fails.
+    /// </remarks>
+    [Fact]
+    public async Task Searching_inside_property_values_still_finds_the_subscription()
+    {
+        await using var scope = fixture.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<BitweenDbContext>();
+        scope.Superuser();
+
+        var doc = new Document(null, "Pentest Searchable Doc", DocumentFormat.Json);
+        db.Set<Document>().Add(doc);
+        await db.SaveChangesAsync();
+
+        var sub = new Subscription("Pentest Searchable Sub", doc.Id);
+        sub.SetDictionaries(
+            handler: new Dictionary<string, string> { ["Url"] = "https://findme.example.test/inbound" },
+            mapper: new Dictionary<string, string>(),
+            receiver: new Dictionary<string, string>(),
+            document: new Dictionary<string, string>(),
+            validator: new Dictionary<string, string>());
+        db.Set<Subscription>().Add(sub);
+        await db.SaveChangesAsync();
+
+        var handler = ActivatorUtilities.CreateInstance<Resources.Subscriptions.Search>(scope.ServiceProvider);
+        // Rule is immaterial — this field is filtered in memory by Contains, not translated.
+        var response = (SearchyResponse<SubscriptionSearch>)await handler.Handle(
+            new SearchyRequest("filter=rawsubscriptionproperties:1:findme.example.test") { PageSize = 500 });
+
+        Assert.Contains(response.Result, r => r.Id == sub.Id);
+    }
+
+    /// <summary>
+    /// GIG.WEB-002, second half. The administrator seeded into every installation ships with a
+    /// password published in our repository; until it is replaced its token is worth nothing.
+    /// </summary>
+    [Fact]
+    public async Task An_unchanged_password_grants_no_permissions()
+    {
+        await using var scope = fixture.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<BitweenDbContext>();
+
+        var account = new Account("Unchanged", "must-change@test.local", "hash", AccountRole.Admin);
+        db.Set<Account>().Add(account);
+        await db.SaveChangesAsync();
+        db.Set<AccountRoleLink>().Add(new AccountRoleLink(account.Id, Role.AdministratorId));
+        await db.SaveChangesAsync();
+
+        var ctx = scope.ServiceProvider.GetRequiredService<RequestContext>();
+        ctx.Set(new ClaimsPrincipal(new ClaimsIdentity(
+            [
+                new Claim(ClaimTypes.NameIdentifier, account.Id.ToString()),
+                new Claim(Bitween.RequestContextExtensions.MustChangePasswordClaim, "true")
+            ], "integration-test")));
+
+        // Administrator by role, and refused anyway.
+        Assert.Empty(await ctx.GetPermissions(db));
+        await Assert.ThrowsAsync<SWUnauthorizedException>(() =>
+            ctx.EnsurePermission(db, Permissions.Subscriptions.View));
+    }
+
+    /// <summary>
+    /// The claim outranks the superuser grant, so no token can carry both and win.
+    /// </summary>
+    [Fact]
+    public async Task An_unchanged_password_outranks_even_the_superuser_claim()
+    {
+        await using var scope = fixture.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<BitweenDbContext>();
+
+        var ctx = scope.ServiceProvider.GetRequiredService<RequestContext>();
+        ctx.Set(new ClaimsPrincipal(new ClaimsIdentity(
+            [
+                new Claim(Bitween.RequestContextExtensions.SuperuserClaim, "true"),
+                new Claim(Bitween.RequestContextExtensions.MustChangePasswordClaim, "true")
+            ], "integration-test")));
+
+        Assert.Empty(await ctx.GetPermissions(db));
+    }
+
+    /// <summary>Choosing a password is what clears the flag, whoever sets it.</summary>
+    [Fact]
+    public void Setting_a_password_clears_the_requirement()
+    {
+        var account = new Account("Seeded", "clears@test.local", "hash", AccountRole.Admin);
+        typeof(Account).GetProperty(nameof(Account.MustChangePassword))!
+            .SetValue(account, true);
+
+        account.SetPassword("Chosen-By-A-Person-9!");
+
+        Assert.False(account.MustChangePassword);
+    }
+
+    /// <summary>
+    /// GIG.WEB-006. The sign-in page reads this endpoint before anyone authenticates, and the
+    /// default GitHub link in it is what led the testers to our public repository — and from there
+    /// to the sample signing key and the default administrator password.
+    /// </summary>
+    [Fact]
+    public async Task Pre_auth_config_withholds_the_vendor_link_at_its_default()
+    {
+        await using var scope = fixture.CreateScope();
+        var handler = ActivatorUtilities.CreateInstance<Resources.Settings.Config>(scope.ServiceProvider);
+
+        var theme = ThemeOf(await handler.Handle());
+
+        Assert.False(theme.ContainsKey("githubLink"));
+        // Still the branding endpoint: what the sign-in page paints has to survive.
+        Assert.True(theme.ContainsKey("primaryColor"));
+        Assert.True(theme.ContainsKey("companyName"));
+        Assert.True(theme.ContainsKey("loginLogo"));
+    }
+
+    /// <summary>
+    /// A deployment that set its own link is publishing its own address, so it gets it back. Only
+    /// the value we ship is withheld.
+    /// </summary>
+    [Fact]
+    public async Task Pre_auth_config_returns_a_vendor_link_someone_chose()
+    {
+        await using var scope = fixture.CreateScope();
+        var themeOptions = scope.ServiceProvider.GetRequiredService<ThemeOptions>();
+        var original = themeOptions.GithubLink;
+        themeOptions.GithubLink = "https://github.com/a-customer-of-ours";
+
+        try
+        {
+            var handler = ActivatorUtilities.CreateInstance<Resources.Settings.Config>(scope.ServiceProvider);
+            var theme = ThemeOf(await handler.Handle());
+
+            Assert.Equal("https://github.com/a-customer-of-ours", theme["githubLink"]);
+        }
+        finally
+        {
+            themeOptions.GithubLink = original;
+        }
+    }
+
+    /// <summary>The anonymous payload is an anonymous type, so the theme comes back by reflection.</summary>
+    private static Dictionary<string, object> ThemeOf(object config)
+    {
+        var theme = config.GetType().GetProperty("Theme")!.GetValue(config);
+        return ((Dictionary<string, object>)theme!);
+    }
+}

From e7a4f50a9224e51a1c9be786ba02158f096010b3 Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:10:22 +0300
Subject: [PATCH 09/12] chore: pass a deployment-specific signing key on deploy

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .github/workflows/bitween-api-cicd-gateway.yml | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/bitween-api-cicd-gateway.yml b/.github/workflows/bitween-api-cicd-gateway.yml
index 4caf2eb7..f0e9d2cc 100644
--- a/.github/workflows/bitween-api-cicd-gateway.yml
+++ b/.github/workflows/bitween-api-cicd-gateway.yml
@@ -94,4 +94,10 @@ jobs:
       dependabot-alerts-token: ${{ secrets.DEPENDABOT_ALERTS_TOKEN }}
 
       # App configuration passed to helm --set-string during deploy (masked)
-      helm-set-secret-values: 'db=${{ secrets.dbConnection }},global.bus.rabbitUrl=${{ secrets.rabbitUrl }},global.cloudFiles.secretAccessKey=${{ secrets.SecretAccessKey }},global.cloudFiles.accessKeyId=${{ secrets.AccessKeyId }},global.cloudFiles.serviceUrl=${{ secrets.ServiceUrl }},global.cloudFiles.bucketName=${{ secrets.BucketName }},environmentVariables.Bitween__RabbitMqManagementUrl=${{ secrets.RabbitMqManagementUrl }},environmentVariables.Bitween__RabbitMqManagementPassword=${{ secrets.RabbitMqManagementPassword }},environmentVariables.Bitween__RabbitMqManagementUsername=${{ secrets.RabbitMqManagementUsername }}'
+      #
+      # global.token.key signs every authentication token. The chart still carries a sample
+      # key as its default, and that value is published in this public repository — anyone
+      # holding it can mint a token for any identity, so the app refuses to start on it.
+      # Set the TokenKey secret to a long random string unique to this environment
+      # (openssl rand -base64 48). Changing it signs out everyone holding an older token.
+      helm-set-secret-values: 'global.token.key=${{ secrets.TokenKey }},db=${{ secrets.dbConnection }},global.bus.rabbitUrl=${{ secrets.rabbitUrl }},global.cloudFiles.secretAccessKey=${{ secrets.SecretAccessKey }},global.cloudFiles.accessKeyId=${{ secrets.AccessKeyId }},global.cloudFiles.serviceUrl=${{ secrets.ServiceUrl }},global.cloudFiles.bucketName=${{ secrets.BucketName }},environmentVariables.Bitween__RabbitMqManagementUrl=${{ secrets.RabbitMqManagementUrl }},environmentVariables.Bitween__RabbitMqManagementPassword=${{ secrets.RabbitMqManagementPassword }},environmentVariables.Bitween__RabbitMqManagementUsername=${{ secrets.RabbitMqManagementUsername }}'

From b7647b70ae3c74f6a8b6f5f931bd66aabd860ae9 Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:10:44 +0300
Subject: [PATCH 10/12] docs: say that the signing key must be your own, local
 checkouts included

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/configuration.md | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/docs/configuration.md b/docs/configuration.md
index 78a8a5e4..904d6712 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -10,12 +10,26 @@ Some values are also **runtime settings** that administrators change in the UI.
 |---|---|
 | `ConnectionStrings:BitweenDb` | `Host=db;Port=5432;Database=bitween;Username=bitween;Password=...` |
 | `ConnectionStrings:RabbitMQ` | `amqp://user:password@rabbitmq:5672/` |
-| `Token:Key` | A random secret of at least 32 characters |
+| `Token:Key` | A random secret of at least 32 characters, unique to this deployment |
 | `Token:Issuer`, `Token:Audience` | Values used to sign and validate JWTs |
 | Storage settings | See [Storage](#storage) |
 
 The service stops at startup with a clear error when the database connection string is missing.
 
+### `Token:Key` must be your own
+
+Whoever holds this key can mint a token for any identity, including one with no account behind
+it. The service **refuses to start** when it is missing, or when it is still the sample value
+`6547647654764764767657658658758765876532542` — which ships as the chart default and is published
+in this repository, so a deployment that never overrode it was open to anyone who read it.
+
+The check runs in every environment, including Development, so **a local checkout needs its own
+key too**: put one in your gitignored `appsettings.Development.json` (or `appsettings.Local.json`).
+Any long random string will do — `openssl rand -base64 48`.
+
+Changing the key invalidates every token already issued, so everyone signs in again. That is the
+intended response to a key you no longer trust.
+
 ## `Bitween` section
 
 | Key | Default | Description |

From 059cd5c23171050e58c69a4b4e1d9af89aa65146 Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:31:29 +0300
Subject: [PATCH 11/12] fix: end existing sessions when a password changes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signing in with a refresh token skips password verification, so a session
opened with the old password outlived the change — which would have let
whoever knew the seeded admin's published password keep full access after
it was replaced.

Also from review: a trailing slash bypassed the sign-in rate limit, short
signing keys were accepted, and the docs still described the removed
break-glass login.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../Resources/Accounts/ChangePassword.cs      |  9 +++++
 .../Resources/Accounts/SetPassword.cs         | 10 ++++++
 .../Tests/PentestFindingTests.cs              | 36 +++++++++++++++++++
 SW.Bitween.Web/ClientApp/e2e/global-setup.ts  |  2 +-
 SW.Bitween.Web/Startup.cs                     | 24 ++++++++++---
 docs/api-reference.md                         |  1 -
 docs/caveats.md                               |  3 +-
 docs/configuration.md                         |  1 -
 docs/deployment.md                            |  2 --
 docs/security.md                              | 15 +++++---
 10 files changed, 87 insertions(+), 16 deletions(-)

diff --git a/SW.Bitween.Api/Resources/Accounts/ChangePassword.cs b/SW.Bitween.Api/Resources/Accounts/ChangePassword.cs
index dd0b911b..3c13599c 100644
--- a/SW.Bitween.Api/Resources/Accounts/ChangePassword.cs
+++ b/SW.Bitween.Api/Resources/Accounts/ChangePassword.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 using FluentValidation;
 using Microsoft.EntityFrameworkCore;
@@ -28,6 +29,14 @@ public async Task<object> Handle(ChangePasswordModel request)
         account.SetPassword(request.NewPassword);
         await dbContext.SaveChangesAsync();
 
+        // Signing in with a refresh token skips password verification entirely — it looks the
+        // account up by id and issues a fresh token from whatever state it is now in. So a session
+        // opened with the old password outlives the change unless the tokens go with it, and
+        // "change the password" would not actually remove whoever you changed it because of.
+        await dbContext.Set<RefreshToken>()
+            .Where(t => t.AccountId == account.Id)
+            .ExecuteDeleteAsync();
+
         return null;
     }
 
diff --git a/SW.Bitween.Api/Resources/Accounts/SetPassword.cs b/SW.Bitween.Api/Resources/Accounts/SetPassword.cs
index 46e5e503..d019c85b 100644
--- a/SW.Bitween.Api/Resources/Accounts/SetPassword.cs
+++ b/SW.Bitween.Api/Resources/Accounts/SetPassword.cs
@@ -1,6 +1,8 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 using FluentValidation;
+using Microsoft.EntityFrameworkCore;
 using SW.Bitween.Domain.Accounts;
 using SW.Bitween.Model;
 using SW.PrimitiveTypes;
@@ -31,6 +33,14 @@ public async Task<object> Handle(int key, SetAccountPasswordModel request)
         account.SetPassword(request.Password);
         await dbContext.SaveChangesAsync();
 
+        // Signing in with a refresh token skips password verification entirely — it looks the
+        // account up by id and issues a fresh token from whatever state it is now in. So a session
+        // opened with the old password outlives the change unless the tokens go with it, and
+        // "change the password" would not actually remove whoever you changed it because of.
+        await dbContext.Set<RefreshToken>()
+            .Where(t => t.AccountId == account.Id)
+            .ExecuteDeleteAsync();
+
         return null;
     }
 
diff --git a/SW.Bitween.IntegrationTests/Tests/PentestFindingTests.cs b/SW.Bitween.IntegrationTests/Tests/PentestFindingTests.cs
index 4e082d35..25679010 100644
--- a/SW.Bitween.IntegrationTests/Tests/PentestFindingTests.cs
+++ b/SW.Bitween.IntegrationTests/Tests/PentestFindingTests.cs
@@ -161,6 +161,42 @@ public void Setting_a_password_clears_the_requirement()
         Assert.False(account.MustChangePassword);
     }
 
+    /// <summary>
+    /// Changing the password ends the sessions opened with the old one.
+    /// </summary>
+    /// <remarks>
+    /// Signing in with a refresh token skips password verification — it looks the account up by id
+    /// and issues a token from whatever state it is now in. Without this, changing a password that
+    /// had leaked would not remove whoever leaked it: their refresh token would still be exchanged
+    /// for a fresh token, and for the seeded administrator that token would come back with the
+    /// restriction lifted. Raised by review on this branch, not by the penetration test.
+    /// </remarks>
+    [Fact]
+    public async Task Changing_a_password_ends_the_sessions_opened_with_the_old_one()
+    {
+        await using var scope = fixture.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<BitweenDbContext>();
+
+        var account = new Account("Session Holder", "ends-sessions@test.local",
+            SecurePasswordHasher.Hash("The-Old-Password-9!"), AccountRole.Member);
+        db.Set<Account>().Add(account);
+        await db.SaveChangesAsync();
+
+        db.Set<RefreshToken>().Add(new RefreshToken(account.Id, LoginMethod.EmailAndPassword));
+        db.Set<RefreshToken>().Add(new RefreshToken(account.Id, LoginMethod.EmailAndPassword));
+        await db.SaveChangesAsync();
+
+        scope.As(account.Id);
+        var handler = ActivatorUtilities.CreateInstance<Resources.Accounts.ChangePassword>(scope.ServiceProvider);
+        await handler.Handle(new ChangePasswordModel
+        {
+            OldPassword = "The-Old-Password-9!",
+            NewPassword = "The-New-Password-9!"
+        });
+
+        Assert.Empty(db.Set<RefreshToken>().Where(t => t.AccountId == account.Id));
+    }
+
     /// <summary>
     /// GIG.WEB-006. The sign-in page reads this endpoint before anyone authenticates, and the
     /// default GitHub link in it is what led the testers to our public repository — and from there
diff --git a/SW.Bitween.Web/ClientApp/e2e/global-setup.ts b/SW.Bitween.Web/ClientApp/e2e/global-setup.ts
index a0d36b87..1f0e3218 100644
--- a/SW.Bitween.Web/ClientApp/e2e/global-setup.ts
+++ b/SW.Bitween.Web/ClientApp/e2e/global-setup.ts
@@ -51,7 +51,7 @@ export default async function purgeTestData() {
   const login = await api.post(`${API}/accounts/login`, {
     data: { Username: ADMIN_EMAIL, Password: ADMIN_PASSWORD },
   });
-  const token: string = login.ok() ? (await login.json()).jwt : "";
+  let token: string = login.ok() ? (await login.json()).jwt : "";
 
   const auth = () => ({ Authorization: `Bearer ${token}` });
 
diff --git a/SW.Bitween.Web/Startup.cs b/SW.Bitween.Web/Startup.cs
index 017b838b..5ac617f5 100644
--- a/SW.Bitween.Web/Startup.cs
+++ b/SW.Bitween.Web/Startup.cs
@@ -536,6 +536,8 @@ private static void WarnIfMsalRedirectUriIsStale(IApplicationBuilder app)
         /// </remarks>
         private const string SampleSigningKey = "6547647654764764767657658658758765876532542";
 
+        private const int MinimumSigningKeyLength = 32;
+
         private void RejectSampleSigningKey()
         {
             var key = Configuration["Token:Key"];
@@ -545,6 +547,13 @@ private void RejectSampleSigningKey()
                     "Token:Key is not configured. Generate a random secret unique to this " +
                     "deployment — tokens cannot be trusted without one.");
 
+            // The length our own configuration documents. A short key is brute-forceable offline
+            // against any token the holder has seen, which is every token they were ever issued.
+            if (key.Length < MinimumSigningKeyLength)
+                throw new InvalidOperationException(
+                    $"Token:Key is {key.Length} characters; it must be at least " +
+                    $"{MinimumSigningKeyLength}. Generate a random secret rather than choosing one.");
+
             if (key == SampleSigningKey)
                 throw new InvalidOperationException(
                     "Token:Key is still the sample value that ships as the default in the " +
@@ -617,10 +626,17 @@ private static void AddRateLimiting(IServiceCollection services)
         /// page ten times would spend the whole sign-in budget on page loads and lock someone out
         /// of an app they had not yet tried to enter.
         /// </remarks>
-        private static bool IsSignInPath(PathString path) =>
-            path.HasValue
-            && path.Value!.StartsWith("/api/", StringComparison.OrdinalIgnoreCase)
-            && path.Value!.EndsWith("/login", StringComparison.OrdinalIgnoreCase);
+        private static bool IsSignInPath(PathString path)
+        {
+            if (!path.HasValue) return false;
+
+            // Routing treats "/api/accounts/login/" as the same endpoint, so the limit has to as
+            // well — otherwise one trailing character moves an attempt to the general budget.
+            var value = path.Value!.TrimEnd('/');
+
+            return value.StartsWith("/api/", StringComparison.OrdinalIgnoreCase)
+                && value.EndsWith("/login", StringComparison.OrdinalIgnoreCase);
+        }
 
         private static string ClientAddress(HttpContext context) =>
             context.Connection.RemoteIpAddress?.ToString() ?? "unknown";
diff --git a/docs/api-reference.md b/docs/api-reference.md
index 733ce612..85a95a95 100644
--- a/docs/api-reference.md
+++ b/docs/api-reference.md
@@ -48,7 +48,6 @@ See [Entry points](entry-points.md) for status codes.
 | `POST /api/accounts/logout` | none | Deletes the refresh token and clears site data |
 | `GET /api/accounts/profile` | signed in | The current member, roles and permissions |
 | `POST /api/accounts/changePassword` | signed in | Change your own password |
-| `POST /api/login` | none | Break-glass sign-in against `Bitween:AdminCredentials` |
 | `GET /api/settings/config` | none | Sign-in options and theme |
 | `GET /api/settings/myversion` | signed in | API version |
 | `GET /api/permissions` | signed in | The permission catalogue |
diff --git a/docs/caveats.md b/docs/caveats.md
index 4b70b04f..8ed7b623 100644
--- a/docs/caveats.md
+++ b/docs/caveats.md
@@ -6,8 +6,7 @@ These behaviours were found while documenting Bitween from its source code, and
 
 | Issue | Where |
 |---|---|
-| Break-glass credentials default to `admin:1234512345`. They return a token with every permission, with no lockout. | `BitweenOptions.AdminCredentials`, `Resources/Login/Login.cs` |
-| The seeded administrator's password is known, and the SYSTEM partner's API key is seeded with a fixed value. | `Data/BitweenDbContext.cs` |
+| The SYSTEM partner's API key is seeded with a fixed value. (The seeded administrator's password is also published, but that account now grants nothing until the password is changed.) | `Data/BitweenDbContext.cs` |
 | Microsoft ID tokens are checked for signature and lifetime but not issuer or audience. A valid token from any tenant or app signs in the Bitween account with the same email. The tenant setting only affects the browser popup. | `Extensions/AccountExtensions.cs` |
 | Creating an exchange by hand, previewing a rules-based mapping and generating a partner key check no permission. Any signed-in member can call them. | `Resources/Xchanges/Create.cs`, `Resources/MappingPreviews/Preview.cs`, `Resources/Partners/GenerateKey.cs` |
 | `GET /api/bitweendocs` needs no sign-in and reads any storage key it is given. | `Resources/BitweenDocs/Get.cs` |
diff --git a/docs/configuration.md b/docs/configuration.md
index 904d6712..a66fa88c 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -50,7 +50,6 @@ intended response to a key you no longer trust.
 | `RabbitMqManagementUrl`, `RabbitMqManagementUsername`, `RabbitMqManagementPassword` | | RabbitMQ management API, needed for queue health. |
 | `ConsumeLegacyEventMessages` | `false` | Also drain the queues that versions before work groups published to. |
 | `CorsOrigins` | empty | Browser origins allowed to call the API with credentials. Set as `Bitween__CorsOrigins__0`, `Bitween__CorsOrigins__1` and so on. |
-| `AdminCredentials` | `admin:1234512345` | Break-glass `user:password`. Always override. |
 | `SettingsEncryptionKey` | | Passphrase that encrypts secret settings in the database. |
 | `ReceiveAttemptRetentionDays` | `30` | Days to keep receive attempts. |
 | `ReceiveAttemptCleanupCron` | `0 0 3 * * ?` | Quartz cron for the receive attempt cleanup. |
diff --git a/docs/deployment.md b/docs/deployment.md
index 7bdcb84c..99f8f1e8 100644
--- a/docs/deployment.md
+++ b/docs/deployment.md
@@ -15,7 +15,6 @@ docker run -p 8080:8080 \
   -e Bitween__StorageProvider=S3 \
   -e CloudFiles__AccessKeyId=... -e CloudFiles__SecretAccessKey=... \
   -e CloudFiles__ServiceUrl=https://s3.example.com -e CloudFiles__BucketName=bitween \
-  -e Bitween__AdminCredentials="..." \
   bitween:local
 ```
 
@@ -38,7 +37,6 @@ helm install bitween ./charts/default \
   --set global.cloudFiles.secretAccessKey=... \
   --set global.cloudFiles.serviceUrl=https://s3.example.com \
   --set global.cloudFiles.bucketName=bitween \
-  --set secrets.Bitween__AdminCredentials="..." \
   --set secrets.Bitween__SettingsEncryptionKey="..." \
   --set ingress.hosts[0]=bitween.example.com
 ```
diff --git a/docs/security.md b/docs/security.md
index db77005e..d3ae05f4 100644
--- a/docs/security.md
+++ b/docs/security.md
@@ -30,11 +30,15 @@ The redirect URI must be `/blank.html` on the Bitween host, such as `https://bit
 
 Bitween does not check the token's issuer or audience. See [Known limitations](caveats.md#security).
 
-### Break-glass login
+### Break-glass login (removed)
 
-`POST /api/login` with `{ "Username": "...", "Password": "..." }` compares the values with `Bitween:AdminCredentials`, written as `user:password`. A match returns a token with every permission, without touching the database, and there is no lockout.
+`POST /api/login` signed in against `Bitween:AdminCredentials` and returned a token with every
+permission, without touching the database and with no lockout. It shipped with a working default —
+`admin:1234512345`, published in this repository — and neither the current nor the legacy UI ever
+called it. A penetration test signed in with it. The endpoint and the setting are gone.
 
-The default in code is `admin:1234512345`. **Override `Bitween__AdminCredentials` in every environment.**
+There is now no sign-in that bypasses the database. If the last account holding Administrator loses
+the role, no request can restore it and the database has to be repaired directly.
 
 ## Tokens and sessions
 
@@ -149,8 +153,9 @@ The trail is written in the same transaction as the change, and no API edits or
 
 ## Production checklist
 
-1. Set `Bitween__AdminCredentials` to an unguessable user name and password.
-2. Change the seeded administrator's password, or add your own administrator and then remove the seeded one.
+1. Change the seeded administrator's password, or add your own administrator and then remove the
+   seeded one. The seeded password is published in this repository, so until it is replaced that
+   account's token grants nothing and the only screen it can reach is the password change.
 3. Replace or remove the SYSTEM partner's API key.
 4. Set `Token__Key` to a long random secret, and choose your own `Token__Issuer` and `Token__Audience`.
 5. Set `Bitween__SettingsEncryptionKey` before saving a Rebex license key.

From ff5d3b853c2b0656c196f3cc1bd29b27e224ea98 Mon Sep 17 00:00:00 2001
From: Hamza Alqurneh <hamza@simplify9.com>
Date: Tue, 15 Sep 2026 16:35:41 +0300
Subject: [PATCH 12/12] fix: test an unsupported format with one that is
 actually unsupported

The test asked for csv, which delimited text then added support for, so it
stopped testing anything and failed on a null error message.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../Tests/MappingPreviewTests.cs                     | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/SW.Bitween.IntegrationTests/Tests/MappingPreviewTests.cs b/SW.Bitween.IntegrationTests/Tests/MappingPreviewTests.cs
index e3f76dca..38c4196e 100644
--- a/SW.Bitween.IntegrationTests/Tests/MappingPreviewTests.cs
+++ b/SW.Bitween.IntegrationTests/Tests/MappingPreviewTests.cs
@@ -133,11 +133,17 @@ public async Task Unreadable_rules_are_a_general_error()
     [Fact]
     public async Task An_unsupported_format_names_what_is_supported()
     {
-        var response = await PreviewAsync(new { version = 1, sourceFormat = "csv" }, "{}");
+        // Named rather than a format that merely happens to be unsupported today: this test asked
+        // for "csv" until delimited text landed, at which point it stopped testing anything and
+        // failed on a null error message instead. Asserting the whole supported list is the half
+        // that has to be kept honest — the next format to arrive is meant to break this line, and
+        // it now says so out loud.
+        var response = await PreviewAsync(new { version = 1, sourceFormat = "yaml" }, "{}");
 
         Assert.Contains("not a source format", response.Error);
-        Assert.Contains("json", response.Error);
-        Assert.Contains("xml", response.Error);
+        Assert.Equal(
+            "'yaml' is not a source format this mapper supports. Supported: csv, json, xml.",
+            response.Error);
     }
 
     [Fact]