@redacto.io/consent-sdk-react 3.4.0 → 3.6.0

package/src/RedactoPrivacyCenter/lib/api.ts

@@ -0,0 +1,468 @@
+import {
+  createCaseRequestServer,
+  fetchActivitiesServer,
+  fetchCaseHistoryServer,
+  fetchProductsServer,
+  fetchUserConsentsServer,
+  getFormDataServer,
+  manageConsentServer,
+  createOtpServer,
+  verifyOtpServer,
+} from '../api/actions';
+import type { BaseUrlContextValue } from '../context/BaseUrlContext';
+import type {
+  ActivityDetail,
+  CaseHistoryDetail,
+  CreateCaseResponse,
+  FormData,
+  OrganizationResponse,
+  UserConsentDetail,
+  UserDataRequest,
+} from './types';
+import { ensureValidToken } from './utils';
+
+// Auth context type for passing to API functions
+export interface AuthContext {
+  accessToken?: string;
+  refreshToken?: string;
+  onError?: (error: Error) => boolean;
+  updateTokens?: (accessToken: string, refreshToken?: string) => void;
+}
+
+// Re-export server actions for client components
+export {
+  createOtpServer as createOtp,
+  exchangeTokenServer as exchangeToken,
+  verifyOtpServer as verifyOtp,
+} from '../api/actions';
+
+// Re-export refreshOtpTokenServer for utils
+export { refreshOtpTokenServer } from '../api/actions';
+
+// Re-export types
+export type {
+  ActivityDetail,
+  CaseHistoryDetail,
+  CreateCaseResponse,
+  FormData,
+  OrganizationResponse,
+  OtpResponse,
+  OtpVerificationResponse,
+  TokenExchangeResponse,
+  UserConsentDetail,
+  UserDataRequest,
+} from './types';
+
+// Keep utility functions
+export { getCookieValue } from './utils';
+
+/**
+ * Check if an error is an authentication/JWT related error
+ */
+function isAuthError(error: any): boolean {
+  const errorMessage = error?.message || '';
+  return (
+    errorMessage.includes('401') ||
+    errorMessage.includes('JWT') ||
+    errorMessage.includes('expired') ||
+    errorMessage.includes('token') ||
+    errorMessage.includes('Unauthorized')
+  );
+}
+
+/**
+ * Handle client-side auth errors by attempting token refresh
+ * If refresh fails, signs out and redirects to sign-in
+ * @returns true if token was refreshed successfully and caller should retry, false otherwise
+ */
+async function handleClientAuthError(
+  error: any,
+  organizationId: string,
+  workspaceId: string,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient']
+): Promise<boolean> {
+  if (isAuthError(error)) {
+    // Try to get a fresh token
+    const newToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (newToken) {
+      // Token refresh succeeded - caller should retry with new token
+      return true;
+    }
+    // Token refresh failed - ensureValidToken already handled sign out and redirect
+    return false;
+  }
+  return false;
+}
+
+export const getFormData = async (
+  organizationId: string,
+  workspaceId: string,
+  contact: string,
+  _isPopup?: boolean,
+  useSessionAuth?: boolean,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient'],
+  language?: string
+): Promise<FormData | null> => {
+  try {
+    // If useSessionAuth is explicitly set to true (case management), use session auth
+    if (useSessionAuth) {
+      return await getFormDataServer(organizationId, workspaceId, contact, undefined, true, consentClient, language);
+    }
+
+    // Ensure we have a valid token before making the API call
+    const authToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!authToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const data = await getFormDataServer(
+      organizationId,
+      workspaceId,
+      contact,
+      authToken,
+      false,
+      consentClient,
+      language
+    );
+    return data;
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAuthToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await getFormDataServer(
+        organizationId,
+        workspaceId,
+        contact,
+        newAuthToken,
+        false,
+        consentClient,
+        language
+      );
+    }
+    console.error('Error fetching form data:', error);
+    if (error.message?.includes('404')) {
+      throw error;
+    }
+    return null;
+  }
+};
+
+export const createCaseRequest = async (
+  organizationId: string,
+  workspaceId: string,
+  data: UserDataRequest,
+  _isPopup?: boolean,
+  useSessionAuth?: boolean,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient']
+): Promise<CreateCaseResponse | null> => {
+  try {
+    // If useSessionAuth is explicitly set to true (case management), use session auth
+    if (useSessionAuth) {
+      return await createCaseRequestServer(organizationId, workspaceId, data, undefined, true, consentClient);
+    }
+
+    // Ensure we have a valid token before making the API call
+    const authToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!authToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    return await createCaseRequestServer(
+      organizationId,
+      workspaceId,
+      data,
+      authToken,
+      false,
+      consentClient
+    );
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAuthToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await createCaseRequestServer(
+        organizationId,
+        workspaceId,
+        data,
+        newAuthToken,
+        false,
+        consentClient
+      );
+    }
+    console.error('Error creating case request:', error);
+    return null;
+  }
+};
+
+export const fetchProducts = async (
+  organizationId: string,
+  workspaceId: string,
+  skip?: number,
+  limit?: number,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient']
+): Promise<Array<{ uuid: string; name: string; description?: string }> | null> => {
+  try {
+    // Ensure we have a valid token before making the API call
+    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!accessToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const result = await fetchProductsServer({
+      organizationId,
+      workspaceId,
+      skip,
+      limit,
+      authToken: accessToken,
+      consentClient,
+    });
+    return result;
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await fetchProductsServer({
+        organizationId,
+        workspaceId,
+        skip,
+        limit,
+        authToken: newAccessToken || undefined,
+        consentClient,
+      });
+    }
+    console.error('Error fetching products:', error);
+    return null;
+  }
+};
+
+export const fetchUserConsents = async (
+  organizationId: string,
+  workspaceId: string,
+  contact: string,
+  offset?: number,
+  limit?: number,
+  search?: string,
+  status?: string,
+  product_uuid?: string,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient'],
+  language?: string
+): Promise<UserConsentDetail | null> => {
+  try {
+    // Ensure we have a valid token before making the API call
+    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!accessToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const result = await fetchUserConsentsServer({
+      organizationId,
+      workspaceId,
+      contact,
+      offset,
+      limit,
+      search,
+      status,
+      product_uuid,
+      language,
+      authToken: accessToken,
+      consentClient,
+    });
+    return result;
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await fetchUserConsentsServer({
+        organizationId,
+        workspaceId,
+        contact,
+        offset,
+        limit,
+        search,
+        status,
+        product_uuid,
+        language,
+        authToken: newAccessToken || undefined,
+        consentClient,
+      });
+    }
+    console.error('Error fetching user consent data:', error);
+    return null;
+  }
+};
+
+export const manageConsent = async ({
+  organizationId,
+  workspaceId,
+  purposeId,
+  contact,
+  action,
+  authContext,
+  consentClient,
+  nominatorContact,
+  dataElementUuids,
+}: {
+  organizationId: string;
+  workspaceId: string;
+  purposeId: string;
+  contact: string;
+  action: 'revoke' | 'regrant' | 'renew';
+  authContext?: AuthContext;
+  consentClient?: BaseUrlContextValue['consentClient'];
+  nominatorContact?: string;
+  dataElementUuids?: string[];
+}): Promise<boolean | null> => {
+  try {
+    // Ensure we have a valid token before making the API call
+    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!accessToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const result = await manageConsentServer({
+      organizationId,
+      workspaceId,
+      purposeId,
+      contact,
+      action,
+      authToken: accessToken,
+      consentClient,
+      nominatorContact,
+      dataElementUuids,
+    });
+    return result;
+  } catch (error: any) {
+    // Re-throw nominator-specific errors (stable code) so the UI can show targeted messages
+    if (error?.name === 'ConsentApiError') {
+      throw error;
+    }
+    // Auth errors (401) mean the request was rejected before processing, so a single retry is safe
+    const recovered = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (recovered) {
+      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await manageConsentServer({
+        organizationId,
+        workspaceId,
+        purposeId,
+        contact,
+        action,
+        authToken: newAccessToken || undefined,
+        consentClient,
+        nominatorContact,
+        dataElementUuids,
+      });
+    }
+    console.error(`Error ${action} consent:`, error);
+    return null;
+  }
+};
+
+export const fetchActivities = async (
+  organizationId: string,
+  workspaceId: string,
+  offset?: number,
+  limit?: number,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient'],
+  language?: string
+): Promise<ActivityDetail | null> => {
+  try {
+    // Ensure we have a valid token before making the API call
+    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!accessToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const result = await fetchActivitiesServer({
+      organizationId,
+      workspaceId,
+      offset,
+      limit,
+      language,
+      authToken: accessToken,
+      consentClient,
+    });
+    return result;
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await fetchActivitiesServer({
+        organizationId,
+        workspaceId,
+        offset,
+        limit,
+        language,
+        authToken: newAccessToken || undefined,
+        consentClient,
+      });
+    }
+    console.error('Error fetching activities:', error);
+    return null;
+  }
+};
+
+export const fetchCaseHistory = async (
+  organizationId: string,
+  workspaceId: string,
+  contact: string,
+  offset?: number,
+  limit?: number,
+  authContext?: AuthContext,
+  consentClient?: BaseUrlContextValue['consentClient'],
+  language?: string
+): Promise<CaseHistoryDetail | null> => {
+  try {
+    // Ensure we have a valid token before making the API call
+    const accessToken = await ensureValidToken(organizationId, workspaceId, undefined, authContext, consentClient);
+    if (!accessToken) {
+      // ensureValidToken already handled sign out and redirect
+      return null;
+    }
+
+    const result = await fetchCaseHistoryServer({
+      organizationId,
+      workspaceId,
+      contact,
+      offset,
+      limit,
+      language,
+      authToken: accessToken,
+      consentClient,
+    });
+    return result;
+  } catch (error: any) {
+    const shouldRetry = await handleClientAuthError(error, organizationId, workspaceId, authContext, consentClient);
+    if (shouldRetry) {
+      // Read from sessionStorage first (synchronously updated) then fall back to context
+      const newAccessToken = sessionStorage.getItem('access_token') || authContext?.accessToken || '';
+      return await fetchCaseHistoryServer({
+        organizationId,
+        workspaceId,
+        contact,
+        offset,
+        limit,
+        language,
+        authToken: newAccessToken || undefined,
+        consentClient,
+      });
+    }
+    console.error('Error fetching case history: ', error);
+    return null;
+  }
+};

package/src/RedactoPrivacyCenter/lib/consent-manager/utils.tsx

@@ -0,0 +1,63 @@
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import { ConsentStatusEnum } from '../types';
+import type { UserConsent } from '../types';
+import { formatDateTime as formatDateTimeShared } from '../../utils/date';
+
+// Re-export shared date formatting
+export const formatDateTime = formatDateTimeShared;
+
+export const useStatusOptions = () => {
+  const { t } = useTranslation();
+  return useMemo(
+    () => [
+      { label: t('statusActive'), value: ConsentStatusEnum.ACTIVE },
+      { label: t('statusWithdrawn'), value: ConsentStatusEnum.WITHDRAWN },
+      { label: t('statusExpired'), value: ConsentStatusEnum.EXPIRED },
+      { label: t('statusDeclined'), value: ConsentStatusEnum.DECLINED },
+    ],
+    [t]
+  );
+};
+
+export const exportTableToCSV = (rows: UserConsent[]) => {
+  if (!rows || rows.length === 0) {
+    console.warn('No data to export');
+    return;
+  }
+
+  const excludedFields = ['Action', 'data_elements'];
+  const headers = Array.from(new Set(rows.flatMap((r) => Object.keys(r))))
+    .filter((key) => !excludedFields.includes(key))
+    .map((key) => key.toUpperCase())
+    .join(',');
+
+  const csvRows = rows.map((row) => {
+    return Object.entries(row)
+      .filter(([key]) => !excludedFields.includes(key))
+      .map(([key, value]) => {
+        let formattedValue = value;
+        if ((key === 'given_date' || key === 'valid_till') && value) {
+          formattedValue = formatDateTime(String(value));
+        }
+        return `"${String(formattedValue).replace(/"/g, '""')}"`;
+      })
+      .join(',');
+  });
+
+  const csvContent = [headers, ...csvRows].join('\n');
+
+  try {
+    const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement('a');
+    link.href = url;
+    link.setAttribute('download', `consent-records.csv`);
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  } catch (error) {
+    console.error('Failed to export CSV:', error);
+  }
+};

package/src/RedactoPrivacyCenter/lib/constants.ts

@@ -0,0 +1,116 @@
+import { RequestTypeEnum } from './types';
+import { useTranslation } from 'react-i18next';
+import { GRIEVANCE_TAB_IDS } from '../components/constant';
+import { menuItemsPC } from '../components/SideMenuBarPC/constants';
+import type { MenuItem } from '../components/SideMenuBarPC/types';
+import type { InternalPage } from '../context/NavigationContext';
+
+export const useRequestTypeLabels = () => {
+  const { t } = useTranslation();
+
+  return {
+    [RequestTypeEnum.ACCESS]: t('access'),
+    [RequestTypeEnum.CORRECTION]: t('correction'),
+    [RequestTypeEnum.ERASURE]: t('erasure'),
+    [RequestTypeEnum.GRIEVANCE]: t('grievance'),
+    [RequestTypeEnum.NOMINATION]: t('nomination'),
+  } as Record<RequestTypeEnum, string>;
+};
+
+export const languageOptions = [
+  { value: 'en', label: 'English' },
+  { value: 'hi', label: 'हिन्दी (Hindi)' },
+  { value: 'te', label: 'తెలుగు (Telugu)' },
+  { value: 'mr', label: 'मराठी (Marathi)' },
+  { value: 'ta', label: 'தமிழ் (Tamil)' },
+  { value: 'ur', label: 'اردو (Urdu)' },
+  { value: 'gu', label: 'ગુજરાતી (Gujarati)' },
+  { value: 'kn', label: 'ಕನ್ನಡ (Kannada)' },
+  { value: 'ml', label: 'മലയാളം (Malayalam)' },
+  { value: 'pa', label: 'ਪੰਜਾਬੀ (Punjabi)' },
+  { value: 'or', label: 'ଓଡ଼ିଆ (Odia)' },
+  { value: 'as', label: 'অসমীয়া (Assamese)' },
+  { value: 'bn', label: 'বাংলা (Bengali)' },
+  { value: 'mai', label: 'मैथिली (Maithili)' },
+  { value: 'ne', label: 'नेपाली (Nepali)' },
+  { value: 'sd', label: 'سنڌي (Sindhi)' },
+  { value: 'doi', label: 'डोगरी (Dogri)' },
+  { value: 'mni-Mtei', label: 'ꯃꯩꯇꯩꯂꯣꯟ (Manipuri)' },
+  { value: 'gom', label: 'कोंकणी (Konkani)' },
+  { value: 'sa', label: 'संस्कृतम् (Sanskrit)' },
+  { value: 'bho', label: 'भोजपुरी (Bhojpuri)' },
+  { value: 'brx', label: 'बड़ो (Bodo)' },
+  { value: 'ks', label: 'كٲشُر (Kashmiri)' },
+  { value: 'sat', label: 'ᱥᱟᱱᱛᱟᱲᱤ (Santali)' },
+];
+
+export const useTimePeriodOptions = () => {
+  const { t } = useTranslation();
+
+  return [
+    { value: '1', label: t('today') },
+    { value: '7', label: t('last7Days') },
+    { value: '30', label: t('last30Days') },
+    { value: '90', label: t('last3Months') },
+  ];
+};
+
+export const useGrievanceTabs = () => {
+  const { t } = useTranslation();
+
+  return [
+    { id: GRIEVANCE_TAB_IDS.ALL, label: t('allRequests') },
+    { id: GRIEVANCE_TAB_IDS.PROCESSING, label: t('processing') },
+    { id: GRIEVANCE_TAB_IDS.COMPLETED, label: t('completed') },
+    { id: GRIEVANCE_TAB_IDS.REJECTED, label: t('rejected') },
+  ];
+};
+
+export type PageChromeConfig = {
+  titleKey: string;
+  descriptionKey: string;
+};
+
+export const PAGE_CHROME_BY_PAGE: Record<InternalPage, PageChromeConfig> = {
+  'consent-manager': {
+    titleKey: 'manageConsent',
+    descriptionKey: 'manageConsentSubtitle',
+  },
+  form: {
+    titleKey: 'grievanceRequests',
+    descriptionKey: 'grievanceSubtitle',
+  },
+  activity: {
+    titleKey: 'activities',
+    descriptionKey: 'activitiesSubtitle',
+  },
+};
+
+const HREF_TO_NAME_KEY: Record<string, string> = {
+  'consent-manager': 'consentManager',
+  form: 'grievance',
+  activity: 'activity',
+};
+
+export const useMenuItemsPC = (): MenuItem[] => {
+  const { t } = useTranslation();
+  return menuItemsPC.map((item) => ({
+    ...item,
+    name: t((item.href && HREF_TO_NAME_KEY[item.href]) ?? item.name),
+  }));
+};
+
+// Activity columns constants
+export const ACTIVITY_COLUMN_SIZES = {
+  TITLE: 220,
+  ACTIVITY_TYPE: 160,
+  DESCRIPTION: 320,
+  TIMESTAMP: 200,
+} as const;
+
+export const ACTIVITY_DESCRIPTION_TRUNCATE_LENGTH = 100;
+
+export const ACTIVITY_DATE_FORMATS = {
+  DISPLAY: 'MMM D, YYYY [at] h:mm A',
+  TOOLTIP: 'MMMM D, YYYY [at] h:mm:ss A',
+} as const;