Implemented partnerui

2026-10-23 00:58:47 +02:00
parent 9ed210613e
commit 8f58e15f0f
27 changed files with 11416 additions and 983 deletions
@@ -1,16 +1,26 @@
 import Hashids from 'hashids';
 import { useQuery } from '@tanstack/react-query';

+const env = (typeof import.meta !== 'undefined' && import.meta.env
+  ? import.meta.env
+  : {}) as Record<string, string | undefined>;
+
+/**
+ * Deterministic Hashids configuration matching pfm-api HasherSettings.
+ * Ensures 100% interoperability with the C# Hashids.net NuGet package on the backend.
+ */
 export const HASHER_SETTINGS = {
-  minHashLength: 11,
-  salt: 'TGlnaHQgQ2hhcm1zLCBNaWRyYW5kQm9va3MgbWFrZSBsb3RzIG9mIG1vbmV5IGFuZCBhcmUgYSBzdWNjZXNzZnVsIHZpcmFsIHN0b3J5IGluIFNvdXRoIEFmcmljYQ==',
+  minHashLength: Number(env.VITE_HASHER_MIN_LENGTH) || 11,
+  salt:
+    (env.VITE_HASHER_SALT as string) ||
+    'TGlnaHQgQ2hhcm1zLCBNaWRyYW5kQm9va3MgbWFrZSBsb3RzIG9mIG1vbmV5IGFuZCBhcmUgYSBzdWNjZXNzZnVsIHZpcmFsIHN0b3J5IGluIFNvdXRoIEFmcmljYQ==',
 };

 let hasher = new Hashids(HASHER_SETTINGS.salt, HASHER_SETTINGS.minHashLength);

 export function updateHasherSettings(salt?: string, minLength?: number | string): void {
  let updated = false;
-  if (salt && salt.trim() !== '') {
+  if (salt && typeof salt === 'string' && salt.trim() !== '') {
    HASHER_SETTINGS.salt = salt.trim();
    updated = true;
  }
@@ -26,43 +36,78 @@ export function updateHasherSettings(salt?: string, minLength?: number | string)
  }
 }

+function isAlreadyHashId(candidate: string): boolean {
+  if (typeof candidate !== 'string' || candidate.length < HASHER_SETTINGS.minHashLength) {
+    return false;
+  }
+  try {
+    const decoded = hasher.decode(candidate);
+    return Array.isArray(decoded) && decoded.length > 0;
+  } catch {
+    return false;
+  }
+}
+
 export function encodeHashIdSync(id: number | string | null | undefined): string {
-  if (id === undefined || id === null || id === '') return '';
+  if (id === undefined || id === null || id === '') {
+    return '';
+  }
+
  if (typeof id === 'number') {
    if (isNaN(id) || !isFinite(id) || id < 0) return '';
    return hasher.encode(id);
  }
+
  const str = String(id).trim();
  if (!str) return '';
-  try {
-    const decoded = hasher.decode(str);
-    if (Array.isArray(decoded) && decoded.length > 0) return str;
-  } catch {}
-  if (/^\d+$/.test(str)) {
-    const num = parseInt(str, 10);
-    if (!isNaN(num) && num >= 0) return hasher.encode(num);
+
+  if (isAlreadyHashId(str)) {
+    return str;
  }
+
+  if (/^\d+$/.test(str)) {
+    try {
+      const num = parseInt(str, 10);
+      if (!isNaN(num) && num >= 0) {
+        return hasher.encode(num);
+      }
+    } catch {
+      // Fall through
+    }
+  }
+
  return str;
 }

 export function decodeHashIdSync(hashId: string | number | null | undefined): number | string {
  if (hashId === undefined || hashId === null || hashId === '') return '';
  if (typeof hashId === 'number') return hashId;
+
  const str = String(hashId).trim();
+  if (!str) return '';
+
  if (/^-?\d+$/.test(str)) {
    const parsed = parseInt(str, 10);
    return isNaN(parsed) ? str : parsed;
  }
+
  try {
    const decoded = hasher.decode(str);
-    if (Array.isArray(decoded) && decoded.length > 0) return Number(decoded[0]);
-  } catch {}
+    if (Array.isArray(decoded) && decoded.length > 0) {
+      return Number(decoded[0]);
+    }
+  } catch {
+    // If decoding fails, return raw string
+  }
+
  return str;
 }

 export function decodeToNumberSync(hashId: number | string | null | undefined): number {
-  if (!hashId) return 0;
-  if (typeof hashId === 'number') return isNaN(hashId) ? 0 : Math.trunc(hashId);
+  if (hashId === null || hashId === undefined || hashId === '') return 0;
+  if (typeof hashId === 'number') {
+    return isNaN(hashId) ? 0 : Math.trunc(hashId);
+  }
  const str = String(hashId).trim();
  if (/^-?\d+$/.test(str)) {
    const parsed = parseInt(str, 10);
@@ -70,22 +115,84 @@ export function decodeToNumberSync(hashId: number | string | null | undefined):
  }
  try {
    const decoded = hasher.decode(str);
-    if (Array.isArray(decoded) && decoded.length > 0) return Number(decoded[0]);
+    if (Array.isArray(decoded) && decoded.length > 0) {
+      return Number(decoded[0]);
+    }
  } catch {}
  const fallback = Number(str);
  return isNaN(fallback) ? 0 : Math.trunc(fallback);
 }

 export const toolsService = {
-  encodeIdSync: encodeHashIdSync,
-  decodeIdSync: decodeHashIdSync,
-  decodeToNumberSync,
-  async encodeId(id: number | string | null | undefined) { return encodeHashIdSync(id); },
-  async decodeId(hashId: string | null | undefined) { return decodeHashIdSync(hashId); },
-  async resolveProjectId(id: number | string) { return encodeHashIdSync(id); },
-  async resolveOrganisationId(id: number | string) { return encodeHashIdSync(id); },
-  async resolveActivityId(id: number | string) { return encodeHashIdSync(id); },
-  async resolveMilestoneId(id: number | string) { return encodeHashIdSync(id); },
+  encodeIdSync(id: number | string | null | undefined): string {
+    return encodeHashIdSync(id);
+  },
+
+  decodeIdSync(hashId: string | number | null | undefined): number | string {
+    return decodeHashIdSync(hashId);
+  },
+
+  decodeToNumberSync(hashId: number | string | null | undefined): number {
+    return decodeToNumberSync(hashId);
+  },
+
+  async encodeId(id: number | string | null | undefined, _context = 'general'): Promise<string> {
+    return encodeHashIdSync(id);
+  },
+
+  async decodeId(hashId: string | null | undefined, _context = 'general'): Promise<number | string> {
+    return decodeHashIdSync(hashId);
+  },
+
+  async resolveProjectId(projectId: number | string): Promise<string> {
+    return encodeHashIdSync(projectId);
+  },
+
+  async resolveOrganisationId(organisationId: number | string): Promise<string> {
+    return encodeHashIdSync(organisationId);
+  },
+
+  async resolveProgrammeId(programmeId: number | string): Promise<string> {
+    return encodeHashIdSync(programmeId);
+  },
+
+  async resolvePortfolioId(portfolioId: number | string): Promise<string> {
+    return encodeHashIdSync(portfolioId);
+  },
+
+  async resolveAwardId(awardId: number | string): Promise<string> {
+    return encodeHashIdSync(awardId);
+  },
+
+  async resolveContractId(contractId: number | string): Promise<string> {
+    return encodeHashIdSync(contractId);
+  },
+
+  async resolveActivityId(activityId: number | string): Promise<string> {
+    return encodeHashIdSync(activityId);
+  },
+
+  async resolveMilestoneId(milestoneId: number | string): Promise<string> {
+    return encodeHashIdSync(milestoneId);
+  },
+
+  async resolveHashedParams<T extends Record<string, any>>(
+    params: T,
+    keysToHash: (keyof T)[]
+  ): Promise<T> {
+    const resolved: any = { ...params };
+    for (const key of keysToHash) {
+      const val = params[key];
+      if (val !== undefined && val !== null) {
+        resolved[key] = encodeHashIdSync(val);
+      }
+    }
+    return resolved;
+  },
+
+  async primeCache(_items: { id: number | string; context: string }[]): Promise<void> {
+    // No-op - instant deterministic computation
+  },
 };

 export function useHashId(id?: number | string | null, context = 'general') {