Add LDAP authentication and camera access controls

frontend/src/App.tsx

@@ -22,6 +22,8 @@ const PublicLayout = lazy(() => import("layouts/PublicLayout"));
 const Recordings = lazy(() => import("pages/recordings/Recordings"));
 const Settings = lazy(() => import("pages/settings"));
 const SystemEvents = lazy(() => import("pages/settings/SystemEvents"));
+const CameraAccess = lazy(() => import("pages/settings/CameraAccess"));
+const LDAP = lazy(() => import("pages/settings/LDAP"));
 const Users = lazy(() => import("pages/settings/Users"));
 const TemplateEditor = lazy(() => import("pages/settings/TemplateEditor"));
 
@@ -96,6 +98,14 @@ function App() {
                   path: "/settings/users",
                   element: <Users />,
                 },
+                {
+                  path: "/settings/ldap",
+                  element: <LDAP />,
+                },
+                {
+                  path: "/settings/camera-access",
+                  element: <CameraAccess />,
+                },
                 {
                   path: "/settings/system-events",
                   element: <SystemEvents />,

frontend/src/components/settings/user/UserDialog.tsx

@@ -49,7 +49,7 @@ function UserDialog({ user, onClose }: UserDialogProps) {
         name,
         username,
         role,
-        assigned_cameras: assignedCameras,
+        assigned_cameras: assignedCameras.length > 0 ? assignedCameras : null,
         preferences: user.preferences,
       },
       {

frontend/src/lib/api/cameraAccess.ts

@@ -0,0 +1,48 @@
+import { useMutation, useQuery } from "@tanstack/react-query";
+
+import { useToast } from "hooks/UseToast";
+import queryClient, { viseronAPI } from "lib/api/client";
+import * as types from "lib/types";
+
+async function cameraAccessConfig() {
+  const response =
+    await viseronAPI.get<types.CameraAccessConfigResponse>("/cameraaccess");
+  return response.data;
+}
+
+export const useCameraAccessConfig = () =>
+  useQuery({
+    queryKey: ["cameraaccess", "config"],
+    queryFn: async () => cameraAccessConfig(),
+  });
+
+async function saveCameraAccessConfig(config: types.CameraAccessConfig) {
+  const response = await viseronAPI.put<types.CameraAccessSaveResponse>(
+    "/cameraaccess",
+    { config },
+  );
+  return response.data;
+}
+
+export const useSaveCameraAccessConfig = () => {
+  const toast = useToast();
+  return useMutation<
+    types.CameraAccessSaveResponse,
+    types.APIErrorResponse,
+    types.CameraAccessConfig
+  >({
+    mutationFn: saveCameraAccessConfig,
+    onSuccess: async () => {
+      toast.success("Camera access saved");
+      queryClient.invalidateQueries({ queryKey: ["cameraaccess", "config"] });
+      queryClient.invalidateQueries({ queryKey: ["auth", "users"] });
+    },
+    onError: async (error) => {
+      toast.error(
+        error.response && error.response.data.error
+          ? `Error saving camera access: ${error.response.data.error}`
+          : `An error occurred: ${error.message}`,
+      );
+    },
+  });
+};

frontend/src/lib/api/ldap.ts

@@ -0,0 +1,84 @@
+import { useMutation, useQuery } from "@tanstack/react-query";
+
+import { useToast } from "hooks/UseToast";
+import queryClient, { viseronAPI } from "lib/api/client";
+import * as types from "lib/types";
+
+async function ldapConfig() {
+  const response = await viseronAPI.get<types.LDAPConfigResponse>("/ldap");
+  return response.data;
+}
+
+export const useLDAPConfig = () =>
+  useQuery({
+    queryKey: ["ldap", "config"],
+    queryFn: async () => ldapConfig(),
+  });
+
+async function saveLDAPConfig(config: types.LDAPConfig) {
+  const response = await viseronAPI.put<types.LDAPSaveResponse>("/ldap", {
+    config,
+  });
+  return response.data;
+}
+
+export const useSaveLDAPConfig = () => {
+  const toast = useToast();
+  return useMutation<
+    types.LDAPSaveResponse,
+    types.APIErrorResponse,
+    types.LDAPConfig
+  >({
+    mutationFn: saveLDAPConfig,
+    onSuccess: async () => {
+      toast.success("LDAP settings saved");
+      queryClient.invalidateQueries({ queryKey: ["ldap", "config"] });
+      queryClient.invalidateQueries({ queryKey: ["auth", "enabled"] });
+    },
+    onError: async (error) => {
+      toast.error(
+        error.response && error.response.data.error
+          ? `Error saving LDAP settings: ${error.response.data.error}`
+          : `An error occurred: ${error.message}`,
+      );
+    },
+  });
+};
+
+async function testLDAPConfig({
+  config,
+  username,
+  password,
+}: {
+  config: types.LDAPConfig;
+  username: string;
+  password: string;
+}) {
+  const response = await viseronAPI.post<types.LDAPTestResponse>("/ldap/test", {
+    config,
+    username,
+    password,
+  });
+  return response.data;
+}
+
+export const useTestLDAPConfig = () => {
+  const toast = useToast();
+  return useMutation<
+    types.LDAPTestResponse,
+    types.APIErrorResponse,
+    { config: types.LDAPConfig; username: string; password: string }
+  >({
+    mutationFn: testLDAPConfig,
+    onSuccess: async () => {
+      toast.success("LDAP test successful");
+    },
+    onError: async (error) => {
+      toast.error(
+        error.response && error.response.data.error
+          ? `LDAP test failed: ${error.response.data.error}`
+          : `An error occurred: ${error.message}`,
+      );
+    },
+  });
+};

frontend/src/lib/types.ts

@@ -143,6 +143,75 @@ export type AuthUsersResponse = {
 export type AuthLoginResponse = AuthTokenResponse;
 export type OnboardingResponse = AuthTokenResponse;
 
+export type LDAPRole = "admin" | "read" | "write" | "deny";
+
+export type LDAPConfig = {
+  enabled: boolean;
+  url: string;
+  bind_dn: string;
+  bind_password: string;
+  bind_password_set: boolean;
+  user_base_dn: string;
+  user_filter: string;
+  username_attribute: string;
+  name_attribute: string;
+  group_base_dn: string;
+  group_filter: string;
+  admin_groups: string[];
+  write_groups: string[];
+  read_groups: string[];
+  default_role: LDAPRole;
+};
+
+export type LDAPConfigResponse = {
+  config: LDAPConfig;
+};
+
+export type CameraAccessGroup = {
+  id: string;
+  name: string;
+  cameras: string[];
+};
+
+export type LDAPCameraAccessRule = {
+  groups: string[];
+  camera_groups: string[];
+  cameras: string[];
+};
+
+export type CameraAccessConfig = {
+  camera_groups: CameraAccessGroup[];
+  ldap_camera_access: LDAPCameraAccessRule[];
+};
+
+export type CameraAccessConfigResponse = {
+  config: CameraAccessConfig;
+};
+
+export type CameraAccessSaveResponse = {
+  success: boolean;
+  restart_required: boolean;
+  errors: string[];
+};
+
+export type LDAPSaveResponse = {
+  success: boolean;
+  restart_required: boolean;
+  errors: string[];
+};
+
+export type LDAPTestResponse = {
+  bind: boolean;
+  user: {
+    username: string;
+    name: string;
+    role: LDAPRole;
+    assigned_cameras: string[] | null;
+    groups: number;
+    password_validated: boolean;
+  } | null;
+};
+
 export type AccessToken = {
   id: string;
   name: string;