Initial commit

frontend/src/contexts/ModulesContext.tsx

@@ -0,0 +1,203 @@
+import { createContext, useContext, useState, useEffect, useCallback } from 'react';
+import type { ReactNode } from 'react';
+import { settingsAPI } from '../api/client';
+import type { UserPermissions } from '../types';
+
+// User-facing modules that can be toggled
+export const TOGGLEABLE_MODULES = [
+  { id: 'feature1', icon: 'playlist_play', defaultEnabled: true },
+  { id: 'feature2', icon: 'download', defaultEnabled: true },
+  { id: 'feature3', icon: 'cast', defaultEnabled: true },
+] as const;
+
+export type ModuleId = typeof TOGGLEABLE_MODULES[number]['id'];
+
+export interface ModuleState {
+  admin: boolean;
+  user: boolean;
+}
+
+interface ModulesContextType {
+  moduleStates: Record<ModuleId, ModuleState>;
+  isModuleEnabled: (moduleId: string) => boolean;
+  isModuleEnabledForUser: (moduleId: string, userPermissions: UserPermissions | undefined, isSuperuser: boolean) => boolean;
+  setModuleEnabled: (moduleId: ModuleId, type: 'admin' | 'user', enabled: boolean) => void;
+  saveModulesToBackend: () => Promise<void>;
+  isLoading: boolean;
+  hasInitialized: boolean;
+}
+
+const ModulesContext = createContext<ModulesContextType | undefined>(undefined);
+
+// Default states
+const getDefaultStates = (): Record<ModuleId, ModuleState> => {
+  const states: Record<string, ModuleState> = {};
+  TOGGLEABLE_MODULES.forEach(m => {
+    states[m.id] = { admin: m.defaultEnabled, user: m.defaultEnabled };
+  });
+  return states as Record<ModuleId, ModuleState>;
+};
+
+export function ModulesProvider({ children }: { children: ReactNode }) {
+  const [moduleStates, setModuleStates] = useState<Record<ModuleId, ModuleState>>(getDefaultStates);
+  const [isLoading, setIsLoading] = useState(true);
+  const [hasInitialized, setHasInitialized] = useState(false);
+
+  // Load module settings from backend
+  const loadModulesFromBackend = useCallback(async () => {
+    try {
+      const settings = await settingsAPI.getModules();
+      const newStates = { ...getDefaultStates() };
+
+      TOGGLEABLE_MODULES.forEach(m => {
+        const adminKey = `module_${m.id}_admin_enabled`;
+        const userKey = `module_${m.id}_user_enabled`;
+
+        // Helper to safely parse boolean
+        const parseBool = (val: any, defaultVal: boolean): boolean => {
+          if (val === undefined || val === null) return defaultVal;
+          if (val === true || val === 'true' || val === 1 || val === '1') return true;
+          if (val === false || val === 'false' || val === 0 || val === '0') return false;
+          return defaultVal;
+        };
+
+        // Check for new keys
+        // If key exists in settings, use it (parsed). If not, use defaultEnabled.
+        // Crucially, if settings[key] is present, we MUST use it, even if it parses to false.
+        if (settings[adminKey] !== undefined) {
+          newStates[m.id].admin = parseBool(settings[adminKey], m.defaultEnabled);
+        } else {
+          newStates[m.id].admin = m.defaultEnabled;
+        }
+
+        if (settings[userKey] !== undefined) {
+          newStates[m.id].user = parseBool(settings[userKey], m.defaultEnabled);
+        } else {
+          newStates[m.id].user = m.defaultEnabled;
+        }
+
+        // Fallback for backward compatibility (if old key exists)
+        const oldKey = `module_${m.id}_enabled`;
+        if (settings[oldKey] !== undefined && settings[adminKey] === undefined) {
+          const val = parseBool(settings[oldKey], m.defaultEnabled);
+          newStates[m.id].admin = val;
+          newStates[m.id].user = val;
+        }
+      });
+
+      setModuleStates(newStates);
+      setHasInitialized(true);
+    } catch (error) {
+      console.error('Failed to load modules from backend:', error);
+      setHasInitialized(true); // Even on error, mark as initialized to prevent saving defaults
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  // Save module settings to backend
+  const saveModulesToBackend = useCallback(async () => {
+    try {
+      const data: Record<string, boolean> = {};
+      TOGGLEABLE_MODULES.forEach(m => {
+        data[`module_${m.id}_admin_enabled`] = moduleStates[m.id].admin;
+        data[`module_${m.id}_user_enabled`] = moduleStates[m.id].user;
+      });
+      await settingsAPI.updateModules(data);
+    } catch (error) {
+      console.error('Failed to save modules to backend:', error);
+      throw error;
+    }
+  }, [moduleStates]);
+
+  // Load modules on mount when token exists
+  useEffect(() => {
+    const token = localStorage.getItem('token');
+    if (token) {
+      loadModulesFromBackend();
+    } else {
+      setIsLoading(false);
+      setHasInitialized(true); // No token, mark as initialized
+    }
+  }, [loadModulesFromBackend]);
+
+  const isModuleEnabled = useCallback((moduleId: string): boolean => {
+    // Dashboard is always enabled
+    if (moduleId === 'dashboard') return true;
+    // Admin modules are always enabled for admins
+    if (moduleId === 'users' || moduleId === 'settings') return true;
+
+    const state = moduleStates[moduleId as ModuleId];
+    return state ? state.admin : true;
+  }, [moduleStates]);
+
+  // Check if module is enabled for a specific user (considering global state + user permissions)
+  const isModuleEnabledForUser = useCallback((
+    moduleId: string,
+    userPermissions: UserPermissions | undefined,
+    isSuperuser: boolean
+  ): boolean => {
+    // Dashboard is always enabled
+    if (moduleId === 'dashboard') return true;
+    // Admin modules are always enabled for admins
+    if (moduleId === 'users' || moduleId === 'settings') return true;
+
+    const state = moduleStates[moduleId as ModuleId];
+    if (!state) return true;
+
+    // 1. If disabled for admin, it's disabled for everyone
+    if (!state.admin) return false;
+
+    // 2. If superuser, they have access (since admin is enabled)
+    if (isSuperuser) return true;
+
+    // 3. If disabled for users globally, regular users can't access
+    if (!state.user) return false;
+
+    // 4. Check user-specific permissions
+    if (userPermissions && userPermissions[moduleId] !== undefined) {
+      return userPermissions[moduleId];
+    }
+
+    // Default: enabled
+    return true;
+  }, [moduleStates]);
+
+  const setModuleEnabled = useCallback((moduleId: ModuleId, type: 'admin' | 'user', enabled: boolean) => {
+    setModuleStates(prev => {
+      const newState = { ...prev };
+      newState[moduleId] = { ...newState[moduleId], [type]: enabled };
+
+      // If admin is disabled, user must be disabled too
+      if (type === 'admin' && !enabled) {
+        newState[moduleId].user = false;
+      }
+
+      return newState;
+    });
+  }, []);
+
+  return (
+    <ModulesContext.Provider
+      value={{
+        moduleStates,
+        isModuleEnabled,
+        isModuleEnabledForUser,
+        setModuleEnabled,
+        saveModulesToBackend,
+        isLoading,
+        hasInitialized,
+      }}
+    >
+      {children}
+    </ModulesContext.Provider>
+  );
+}
+
+export function useModules() {
+  const context = useContext(ModulesContext);
+  if (context === undefined) {
+    throw new Error('useModules must be used within a ModulesProvider');
+  }
+  return context;
+}