filtre admin ok

server/controllers/mediatheque.ts

@@ -1,8 +1,10 @@
 import type { Request, Response } from 'express';
+import { map } from 'leaflet';
 import { Brackets } from 'typeorm';
 
 import type { Filter } from '../../types/mediatheque.type';
 import { Activity } from '../entities/activity';
+import { User } from '../entities/user';
 import { AppDataSource } from '../utils/data-source';
 import { Controller } from './controller';
 
@@ -41,4 +43,35 @@ mediathequeController.post({ path: '' }, async (req: Request, res: Response) =>
   }
 });
 
+mediathequeController.post({ path: '/pelico' }, async (req: Request, res: Response) => {
+  try {
+    const filters: Array<Filter[]> = req.body.filters || [];
+
+    if (!Array.isArray(filters)) {
+      return res.status(400).send({ error: 'Invalid filters format' });
+    }
+
+    const subQueryBuilderUser = AppDataSource.getRepository(User)
+      .createQueryBuilder('user')
+      .where('user.type = :superAdmin', { superAdmin: 0 })
+      .orWhere('user.type = :admin', { admin: 1 })
+      .orWhere('user.type = :mediator', { mediator: 2 });
+
+    const users = await subQueryBuilderUser.getMany();
+
+    const usersId: number[] = users.map((user) => user.id);
+
+    const subQueryBuilderActivity = AppDataSource.getRepository(Activity)
+      .createQueryBuilder('activity')
+      .where('activity.userId IN (:...usersId)', { usersId });
+
+    const activities = await subQueryBuilderActivity.getMany();
+
+    res.send(activities);
+  } catch (error) {
+    console.error('Error fetching media data:', error);
+    res.status(500).send({ error: 'Internal Server Error' });
+  }
+});
+
 export { mediathequeController };

src/api/mediatheque/mediatheque.get-only-pelico.ts

@@ -0,0 +1,23 @@
+import { useQuery } from 'react-query';
+
+import { axiosRequest } from 'src/utils/axiosRequest';
+import type { Filter } from 'types/mediatheque.type';
+
+async function getOnlyPelicoMediatheque(params: { filters: Array<Filter[]> }) {
+  const { filters } = params;
+
+  return (
+    await axiosRequest({
+      method: 'POST',
+      baseURL: '/api',
+      url: '/mediatheque/pelico',
+      data: {
+        filters: filters,
+      },
+    })
+  ).data;
+}
+
+export const useGetOnlyPelicoMediatheque = (filters: Array<Filter[]>) => {
+  return useQuery(['OnlyPelicoMediatheque', filters], () => getOnlyPelicoMediatheque({ filters }));
+};

src/components/admin/mediatheque/CheckboxAdmin.tsx

@@ -7,22 +7,18 @@ import PelicoNeutre from 'src/svg/pelico/pelico_neutre.svg';
 
 const CheckboxAdmin = () => {
   const label = { inputProps: { 'aria-label': 'Pelico' } };
-  const { setFilters } = useContext(MediathequeContext);
+  const { setFilters, setUseAdminData } = useContext(MediathequeContext);
 
   const handleCheckboxChange = (event: React.ChangeEvent<HTMLInputElement>) => {
     console.log(event.target.checked);
     if (event.target.checked === false) {
       setFilters([[]]);
       console.log("c'est faux");
+      setUseAdminData(false);
     }
     if (event.target.checked === true) {
-      setFilters([
-        [
-          { table: 'activity', column: 'type', values: [6] },
-          { table: 'activity', column: 'subType', values: [2] },
-        ],
-      ]);
       console.log("c'est vrai");
+      setUseAdminData(true);
     }
   };
 

src/contexts/mediathequeContext.tsx

@@ -1,6 +1,7 @@
-import React, { createContext, useState, useMemo } from 'react';
+import React, { createContext, useState, useMemo, useEffect } from 'react';
 
 import { useGetMediatheque } from 'src/api/mediatheque/mediatheque.get';
+import { useGetOnlyPelicoMediatheque } from 'src/api/mediatheque/mediatheque.get-only-pelico';
 import type { Filter } from 'types/mediatheque.type';
 
 type MediathequeProviderProps = {
@@ -11,67 +12,91 @@ type MediathequeContextType = {
   filters: Array<Filter[]>;
   setFilters: React.Dispatch<React.SetStateAction<Array<Filter[]>>>;
   allFiltered: [];
+  useAdminData: boolean;
+  setUseAdminData: React.Dispatch<React.SetStateAction<boolean>>;
 };
 
 const MediathequeContext = createContext<MediathequeContextType>({
   filters: [],
   setFilters: () => {},
   allFiltered: [],
+  useAdminData: false,
+  setUseAdminData: () => {},
 });
 
 export const MediathequeProvider: React.FC<MediathequeProviderProps> = ({ children }) => {
   const [filters, setFilters] = useState<Array<Filter[]>>([[]]);
-  console.log("filters :", filters);
+  console.log('filters :', filters);
+  const [useAdminData, setUseAdminData] = useState(false);
 
-  const { data: allData } = useGetMediatheque(filters);
-  console.log(allData);
+  const { data: usersData } = useGetMediatheque(filters);
+  const { data: pelicoData } = useGetOnlyPelicoMediatheque(filters);
+  console.log('usersData', usersData);
+  console.log('pelicoData', pelicoData);
+  const [dataToUse, setDataToUse] = useState([]);
+  const [dataToDisplay, setDataToDisplay] = useState([]);
 
-  const activitiesMediaFinder = allData?.map(
-    ({
-      id,
-      content,
-      subType,
-      type,
-      villageId,
-      userId,
-    }: {
-      id: number;
-      content: object;
-      subType: number;
-      type: number;
-      villageId: number;
-      userId: number;
-    }) => {
-      const result = { id, subType, type, villageId, userId, content: [] };
-      if (content.game) {
-        content.game.map(({ inputs }) =>
-          inputs.map((input: { type: number; selectedValue: string }) => {
-            if (input.type === 3 || input.type === 4) {
-              result.content.push({ type: input.type === 3 ? 'image' : 'video', value: input.selectedValue });
-            }
-          }),
-        );
-      } else {
-        content.map(({ type, value }) => {
-          const wantedTypes = ['image', 'video', 'sound'];
-          if (wantedTypes.includes(type)) {
-            result.content.push({ type, value });
+  useEffect(() => {
+    if (useAdminData === true) {
+      setDataToUse(pelicoData);
+    } else {
+      setDataToUse(usersData);
+    }
+  }, [pelicoData, useAdminData, usersData]);
+
+  console.log('dataToUse = ', dataToUse);
+
+  const activitiesMediaFinder = Array.isArray(dataToUse)
+    ? dataToUse.map(
+        ({
+          id,
+          content,
+          subType,
+          type,
+          villageId,
+          userId,
+        }: {
+          id: number;
+          content: object;
+          subType: number;
+          type: number;
+          villageId: number;
+          userId: number;
+        }) => {
+          const result = { id, subType, type, villageId, userId, content: [] };
+          if (content.game) {
+            content.game.map(({ inputs }) =>
+              inputs.map((input: { type: number; selectedValue: string }) => {
+                if (input.type === 3 || input.type === 4) {
+                  result.content.push({ type: input.type === 3 ? 'image' : 'video', value: input.selectedValue });
+                }
+              }),
+            );
+          } else {
+            content.map(({ type, value }) => {
+              const wantedTypes = ['image', 'video', 'sound'];
+              if (wantedTypes.includes(type)) {
+                result.content.push({ type, value });
+              }
+            });
           }
-        });
-      }
-      return result;
-    },
-  );
+          return result;
+        },
+      )
+    : [];
 
   const dataFiltered = activitiesMediaFinder;
+  console.log("Les datas filtrées ======== ", dataFiltered)
 
   const value = useMemo(
     () => ({
       filters,
       setFilters,
       allFiltered: dataFiltered || [],
+      useAdminData,
+      setUseAdminData,
     }),
-    [filters, dataFiltered],
+    [filters, dataFiltered, useAdminData],
   );
 
   return <MediathequeContext.Provider value={value}>{children}</MediathequeContext.Provider>;