🆕 Create Custom Bage & Security update

src/api/badges/CustomBadgeApi.ts

@@ -0,0 +1,172 @@
+import { GetConfiguration, GetLocalizationManager } from '@nitrots/nitro-renderer';
+import { getAccessToken } from '../auth';
+
+export interface CustomBadgeRecord
+{
+    badgeId: string;
+    badgeCode: string;
+    name: string;
+    description: string;
+    dateCreated: number;
+    dateEdit: number;
+    url: string;
+}
+
+export interface CustomBadgeListResponse
+{
+    badges: CustomBadgeRecord[];
+    max: number;
+    badgeWidth: number;
+    badgeHeight: number;
+    maxBadgeSizeBytes: number;
+    priceBadge?: number;
+    currencyType?: number;
+}
+
+export interface CustomBadgeError
+{
+    error: string;
+    code?: string;
+}
+
+const interpolate = (value: string): string =>
+{
+    try { return GetConfiguration().interpolate(value); }
+    catch { return value; }
+};
+
+const getConfigUrl = (key: string, fallback: string): string =>
+    interpolate(GetConfiguration().getValue<string>(key, fallback));
+
+const buildUrl = (key: string, fallback: string, badgeId?: string): string =>
+{
+    const template = getConfigUrl(key, fallback);
+    if(!badgeId) return template;
+    if(template.includes('%badgeId%')) return template.replace(/%badgeId%/g, encodeURIComponent(badgeId));
+    return template + (template.endsWith('/') ? '' : '/') + encodeURIComponent(badgeId);
+};
+
+const authHeaders = (): Record<string, string> =>
+{
+    const headers: Record<string, string> = {
+        'Accept': 'application/json',
+        'X-Requested-With': 'NitroCustomBadges'
+    };
+    const token = getAccessToken();
+    if(token) headers['Authorization'] = `Bearer ${ token }`;
+    return headers;
+};
+
+const parseJson = async <T>(response: Response): Promise<T> =>
+{
+    const text = await response.text();
+    if(!text) return {} as T;
+    try { return JSON.parse(text) as T; }
+    catch { throw new Error('Invalid response from server.'); }
+};
+
+const throwOnError = async (response: Response): Promise<void> =>
+{
+    if(response.ok) return;
+    const payload = await parseJson<CustomBadgeError>(response);
+    const message = payload?.error || `Request failed (${ response.status }).`;
+    const err = new Error(message) as Error & { status: number; code?: string };
+    err.status = response.status;
+    if(payload?.code) err.code = payload.code;
+    throw err;
+};
+
+export const fetchCustomBadges = async (): Promise<CustomBadgeListResponse> =>
+{
+    const url = buildUrl('badges.custom.list.endpoint', '/api/badges/custom');
+    const response = await fetch(url, { method: 'GET', credentials: 'include', headers: authHeaders() });
+    await throwOnError(response);
+    return parseJson<CustomBadgeListResponse>(response);
+};
+
+export const createCustomBadge = async (body: { name: string; description: string; image: string }): Promise<CustomBadgeRecord> =>
+{
+    const url = buildUrl('badges.custom.create.endpoint', '/api/badges/custom');
+    const response = await fetch(url, {
+        method: 'POST',
+        credentials: 'include',
+        headers: { ...authHeaders(), 'Content-Type': 'application/json' },
+        body: JSON.stringify(body)
+    });
+    await throwOnError(response);
+    return parseJson<CustomBadgeRecord>(response);
+};
+
+export const updateCustomBadge = async (badgeId: string, body: { name: string; description: string; image: string }): Promise<CustomBadgeRecord> =>
+{
+    const url = buildUrl('badges.custom.update.endpoint', '/api/badges/custom/%badgeId%', badgeId);
+    const response = await fetch(url, {
+        method: 'PUT',
+        credentials: 'include',
+        headers: { ...authHeaders(), 'Content-Type': 'application/json' },
+        body: JSON.stringify(body)
+    });
+    await throwOnError(response);
+    return parseJson<CustomBadgeRecord>(response);
+};
+
+export const deleteCustomBadge = async (badgeId: string): Promise<void> =>
+{
+    const url = buildUrl('badges.custom.delete.endpoint', '/api/badges/custom/%badgeId%', badgeId);
+    const response = await fetch(url, { method: 'DELETE', credentials: 'include', headers: authHeaders() });
+    await throwOnError(response);
+};
+
+export const isCustomBadgeCode = (code: string | null | undefined): boolean =>
+{
+    if(!code) return false;
+    return /^CUST[A-Z0-9]{5}-\d+$/.test(code);
+};
+
+let customBadgeTextsLoadPromise: Promise<void> | null = null;
+
+const injectTextsIntoLocalization = (texts: Record<string, string> | null | undefined): void =>
+{
+    if(!texts) return;
+    let manager: ReturnType<typeof GetLocalizationManager> | null = null;
+    try { manager = GetLocalizationManager(); }
+    catch { return; }
+    if(!manager || typeof manager.setValue !== 'function') return;
+    for(const key of Object.keys(texts))
+    {
+        const value = texts[key];
+        if(typeof value === 'string') manager.setValue(key, value);
+    }
+};
+
+export const ensureCustomBadgeTexts = (): Promise<void> =>
+{
+    if(customBadgeTextsLoadPromise) return customBadgeTextsLoadPromise;
+    customBadgeTextsLoadPromise = (async () =>
+    {
+        try
+        {
+            const url = buildUrl('badges.custom.texts.endpoint', '/api/badges/custom/texts');
+            const response = await fetch(url, { method: 'GET', credentials: 'include', headers: { 'Accept': 'application/json' } });
+            if(!response.ok) return;
+            const payload = await parseJson<{ texts: Record<string, string> }>(response);
+            injectTextsIntoLocalization(payload.texts);
+        }
+        catch {}
+    })();
+    return customBadgeTextsLoadPromise;
+};
+
+export const refreshCustomBadgeTexts = (): Promise<void> =>
+{
+    customBadgeTextsLoadPromise = null;
+    return ensureCustomBadgeTexts();
+};
+
+export const setCustomBadgeText = (badgeId: string, name: string, description: string): void =>
+{
+    injectTextsIntoLocalization({
+        [`badge_name_${ badgeId }`]: name || badgeId,
+        [`badge_desc_${ badgeId }`]: description || ''
+    });
+};

src/api/badges/index.ts

@@ -0,0 +1 @@
+export * from './CustomBadgeApi';