Manually applied two PRs

Author: jzongker

.changeset/currency-helper-static-rates.md

@@ -0,0 +1,5 @@
+---
+"@churchapps/helpers": major
+---
+
+CurrencyHelper now caches exchange rates in memory. Call `initializeExchangeRates()` once at app start; `convertDonation`, `convertDonationTotals`, `convertAmount`, and `convertAmountWithLocale` then read the cached rates and no longer take a `rates` argument (breaking). Also: the localStorage rate cache is keyed per base currency, `convertDonation` gains an optional `withCurrencyLabel` flag, conversions round to 2 decimals, and `convertAmountWithLocale` is now synchronous.

.changeset/dropbox-numeric-sort.md

@@ -0,0 +1,5 @@
+---
+"@churchapps/content-providers": patch
+---
+
+Dropbox provider now sorts folder contents by name numeric-aware, so lesson media with 01/02/03-style prefixes list and import in order ("2 Song" before "10 Closer") instead of Dropbox's arbitrary order.

apphelper/public/locales/en.json

@@ -354,6 +354,7 @@
 	},
 	"wrapper": {
 		"chatWith": "Chat with",
+		"currentChurch": "Current church",
 		"deleteChurch": "Delete",
 		"editAccount": "Edit Account",
 		"editChurchProfile": "Edit Church Profile",

apphelper/src/components/wrapper/UserMenu.tsx

@@ -105,6 +105,17 @@ const UserMenuContent: React.FC<Props> = React.memo((props) => {
     const churchId = UserHelper.currentUserChurch.church.id;
     const result: React.ReactElement[] = [];
 
+    const churchName = props.context?.userChurch?.church?.name;
+    if (churchName) {
+      result.push(
+        <Box key="currentChurch" sx={{ px: 2, py: 1 }}>
+          <Typography variant="caption" sx={{ color: "text.secondary", display: "block" }}>{getLabel("wrapper.currentChurch", "Current church")}</Typography>
+          <Typography variant="body2" sx={{ fontWeight: 600 }}>{churchName}</Typography>
+        </Box>
+      );
+      result.push(<div key="church-divider" style={{ borderTop: "1px solid #CCC", marginBottom: 4 }}></div>);
+    }
+
     result.push(<NavItem onClick={() => { modalStateStore.setShowPM(true); }} label={getLabel("wrapper.messages", "Messages")} icon="mail" key="/messages" onNavigate={props.onNavigate} badgeCount={directNotificationCounts.pmCount} />);
 
     result.push(<NavItem onClick={() => { modalStateStore.setShowNotifications(true); }} label={getLabel("wrapper.notifications", "Notifications")} icon="notifications" key="/notifications" onNavigate={props.onNavigate} badgeCount={directNotificationCounts.notificationCount} />);

content-providers/src/providers/dropbox/DropboxConverters.ts

@@ -24,5 +24,10 @@ export function filterMediaEntries(entries: DropboxEntry[]): { folders: DropboxF
     if (entry[".tag"] === "folder") folders.push(entry);
     else if (entry[".tag"] === "file" && isMediaFile(entry.name)) mediaFiles.push(entry);
   }
+  // Dropbox returns entries in arbitrary order; sort by name numeric-aware so 01/02/03-style
+  // prefixes order naturally ("2 Song" before "10 Closer") instead of lexically.
+  const byName = (a: { name: string }, b: { name: string }) => a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
+  folders.sort(byName);
+  mediaFiles.sort(byName);
   return { folders, mediaFiles };
 }

content-providers/tests/dropboxConverters.test.ts

@@ -0,0 +1,25 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { filterMediaEntries } from "../src/providers/dropbox/DropboxConverters";
+import { DropboxEntry } from "../src/providers/dropbox/DropboxInterfaces";
+
+const file = (name: string): DropboxEntry => ({ ".tag": "file", id: "id:" + name, name, path_lower: "/" + name.toLowerCase(), path_display: "/" + name, size: 100, is_downloadable: true });
+const folder = (name: string): DropboxEntry => ({ ".tag": "folder", id: "id:" + name, name, path_lower: "/" + name.toLowerCase(), path_display: "/" + name });
+
+test("filterMediaEntries orders media files numeric-aware, not lexically", () => {
+  const { mediaFiles } = filterMediaEntries([file("11 Closer.png"), file("2 Song.png"), file("01 Opener.png")]);
+  assert.deepEqual(mediaFiles.map((f) => f.name), ["01 Opener.png", "2 Song.png", "11 Closer.png"]);
+});
+
+test("filterMediaEntries sorts folders independently of files and drops non-media files", () => {
+  const { folders, mediaFiles } = filterMediaEntries([
+    folder("10 Week"),
+    folder("2 Week"),
+    file("notes.txt"),
+    file("3 Clip.mp4"),
+    file("1 Clip.mp4")
+  ]);
+  assert.deepEqual(folders.map((f) => f.name), ["2 Week", "10 Week"]);
+  assert.deepEqual(mediaFiles.map((f) => f.name), ["1 Clip.mp4", "3 Clip.mp4"]);
+});

helpers/src/CurrencyHelper.ts

@@ -9,6 +9,10 @@ type RatesCache = {
 export class CurrencyHelper {
   static CACHE_KEY = "exchange_rates_cache";
   static CACHE_EXPIRATION = 12 * 60 * 60 * 1000; // 12 hours
+  // Rates for the church's base currency, cached in memory by initializeExchangeRates()
+  // so conversions don't each have to fetch or be handed a rates map.
+  static rates: Record<string, number> = {};
+  static currentBase = "";
 
   static loadCurrency = async () => {
     const gateways = await ApiHelper.get("/gateways", "GivingApi");
@@ -92,10 +96,21 @@ export class CurrencyHelper {
     return currencyLocaleMap[currency] || "en-US";
   }
 
+  // Populate the in-memory rate cache for the church's base currency. Call once at app start;
+  // it no-ops when the base currency is unchanged and rates are already loaded.
+  static async initializeExchangeRates() {
+    const baseCurrency = await this.loadCurrency();
+    if (baseCurrency === this.currentBase && Object.keys(this.rates).length > 0) return;
+    this.currentBase = baseCurrency;
+    this.rates = await this.getExchangeRates(baseCurrency);
+  }
+
   static async getExchangeRates(
     baseCurrency: string
   ): Promise<Record<string, number>> {
-    const cached = localStorage.getItem(this.CACHE_KEY);
+    // Keyed per base currency so switching bases doesn't return the wrong cached rates.
+    const cacheKey = `${this.CACHE_KEY}_${baseCurrency}`;
+    const cached = localStorage.getItem(cacheKey);
 
     if (cached) {
       const parsed: RatesCache = JSON.parse(cached);
@@ -117,47 +132,42 @@ export class CurrencyHelper {
       timestamp: Date.now()
     };
 
-    localStorage.setItem(this.CACHE_KEY, JSON.stringify(cache));
+    localStorage.setItem(cacheKey, JSON.stringify(cache));
 
     return data.rates;
   }
 
   static convertDonation(
     donation: { currency: string; amount: number },
-    rates: Record<string, number>,
-    targetCurrency: string
+    targetCurrency: string,
+    withCurrencyLabel: boolean = true
   ) {
     const converted = this.convertAmount(
       Number(donation.amount || 0),
       donation.currency?.toUpperCase() || "USD",
-      targetCurrency,
-      rates
+      targetCurrency
     );
 
+    if (!withCurrencyLabel) return Number(converted).toFixed(2);
+
     return this.formatCurrencyWithLocale(converted, targetCurrency);
   }
 
   static convertDonationTotals(
     donations: { currency: string; amount: number }[],
-    rates: Record<string, number>,
     targetCurrency: string
   ) {
     const grouped: Record<string, number> = {};
 
     donations.forEach((donation) => {
       const currency = donation.currency?.toUpperCase() || "USD";
-
-      if (!grouped[currency]) {
-        grouped[currency] = 0;
-      }
-
-      grouped[currency] += Number(donation.amount || 0);
+      grouped[currency] = (grouped[currency] || 0) + Number(donation.amount || 0);
     });
 
     let total = 0;
 
     Object.entries(grouped).forEach(([currency, amount]) => {
-      total += this.convertAmount(amount, currency, targetCurrency, rates);
+      total += this.convertAmount(amount, currency, targetCurrency);
     });
 
     return this.formatCurrencyWithLocale(total, targetCurrency);
@@ -166,37 +176,33 @@ export class CurrencyHelper {
   static convertAmount(
     amount: number,
     fromCurrency: string,
-    toCurrency: string,
-    rates: Record<string, number>
+    toCurrency: string
   ): number {
-    const from = fromCurrency.toUpperCase();
-    const to = toCurrency.toUpperCase();
+    const from = (fromCurrency || "USD").toUpperCase();
+    const to = (toCurrency || "USD").toUpperCase();
 
     if (from === to) {
       return amount;
     }
 
-    const rate = rates[from];
+    const rate = this.rates[from];
 
     if (!rate) {
       return amount;
     }
 
-    return amount / rate;
+    return Number((amount / rate).toFixed(2));
   }
 
-  //this is just temporary, we can remove this later
-  static async convertAmountWithLocale(
+  static convertAmountWithLocale(
     amount: number,
     donationCurrency: string,
-    selectedCurrency: string,
-    rates: Record<string, number>
+    selectedCurrency: string
   ) {
     const converted = this.convertAmount(
       amount,
       donationCurrency,
-      selectedCurrency,
-      rates
+      selectedCurrency
     );
 
     return this.formatCurrencyWithLocale(converted, selectedCurrency);

helpers/tests/currencyHelper.test.ts

@@ -27,28 +27,61 @@ test("formatCurrencyWithLocale renders amount with the currency's symbol, not it
 });
 
 test("convertAmount returns the input amount unchanged when currencies match or the rate is missing", () => {
-  assert.equal(CurrencyHelper.convertAmount(50, "usd", "USD", {}), 50);
-  assert.equal(CurrencyHelper.convertAmount(50, "usd", "eur", {}), 50);
+  CurrencyHelper.rates = {};
+  assert.equal(CurrencyHelper.convertAmount(50, "usd", "USD"), 50);
+  assert.equal(CurrencyHelper.convertAmount(50, "usd", "eur"), 50);
 });
 
-test("convertAmount divides by the target's rate relative to the base currency", () => {
-  // rates keyed by the *source* currency here, per convertAmount's `rates[from]` lookup
-  const result = CurrencyHelper.convertAmount(100, "usd", "eur", { USD: 2 });
-  assert.equal(result, 50);
+test("convertAmount divides by the source currency's cached rate and rounds to 2 decimals", () => {
+  CurrencyHelper.rates = { USD: 2 };
+  assert.equal(CurrencyHelper.convertAmount(100, "usd", "eur"), 50);
+  // 100 / 3 = 33.333... rounds to 33.33
+  CurrencyHelper.rates = { USD: 3 };
+  assert.equal(CurrencyHelper.convertAmount(100, "usd", "eur"), 33.33);
 });
 
-test("convertDonation converts and formats a single donation using its own currency", () => {
-  const formatted = CurrencyHelper.convertDonation({ currency: "usd", amount: 100 }, { USD: 2 }, "eur");
+test("convertAmount tolerates a null/undefined currency instead of throwing", () => {
+  CurrencyHelper.rates = {};
+  assert.equal(CurrencyHelper.convertAmount(50, undefined as unknown as string, "eur"), 50);
+  assert.equal(CurrencyHelper.convertAmount(50, "eur", null as unknown as string), 50);
+});
+
+test("convertDonation converts and formats a single donation using the cached rates", () => {
+  CurrencyHelper.rates = { USD: 2 };
+  const formatted = CurrencyHelper.convertDonation({ currency: "usd", amount: 100 }, "eur");
   assert.ok(formatted.includes("€"), formatted);
+  assert.ok(formatted.includes("50"), formatted);
+});
+
+test("convertDonation with withCurrencyLabel=false returns a bare 2-decimal amount", () => {
+  CurrencyHelper.rates = { USD: 2 };
+  assert.equal(CurrencyHelper.convertDonation({ currency: "usd", amount: 100 }, "eur", false), "50.00");
 });
 
 test("convertDonationTotals groups by currency before converting and summing", () => {
+  CurrencyHelper.rates = { USD: 2 };
   const donations = [
     { currency: "usd", amount: 100 },
     { currency: "usd", amount: 50 },
     { currency: "eur", amount: 10 }
   ];
   // usd group (150) / rate 2 = 75, plus eur group (10, same-currency passthrough) = 85
-  const formatted = CurrencyHelper.convertDonationTotals(donations, { USD: 2 }, "eur");
+  const formatted = CurrencyHelper.convertDonationTotals(donations, "eur");
   assert.ok(formatted.includes("85"), formatted);
 });
+
+test("initializeExchangeRates caches rates once and no-ops while the base is unchanged", async (t) => {
+  CurrencyHelper.rates = {};
+  CurrencyHelper.currentBase = "";
+  t.mock.method(CurrencyHelper, "loadCurrency", async () => "usd");
+  const getRates = t.mock.method(CurrencyHelper, "getExchangeRates", async () => ({ EUR: 0.9 }));
+
+  await CurrencyHelper.initializeExchangeRates();
+  assert.deepEqual(CurrencyHelper.rates, { EUR: 0.9 });
+  assert.equal(CurrencyHelper.currentBase, "usd");
+  assert.equal(getRates.mock.callCount(), 1);
+
+  // Same base + rates already loaded → should short-circuit without refetching.
+  await CurrencyHelper.initializeExchangeRates();
+  assert.equal(getRates.mock.callCount(), 1);
+});