Merge 1a7dc7fec2 into ee7a7a0544

.gitignore

@@ -41,6 +41,7 @@ build/Release
 # Dependency directories
 node_modules/
 jspm_packages/
+mongo-backup/
 
 # Snowpack dependency directory (https://snowpack.dev/)
 web_modules/

client/package-lock.json

@@ -43,6 +43,7 @@
                 "@babel/preset-typescript": "^7.23.3",
                 "@eslint/js": "^9.21.0",
                 "@testing-library/dom": "^10.4.0",
+                "@testing-library/user-event": "^14.6.1",
                 "@testing-library/jest-dom": "^6.6.3",
                 "@testing-library/react": "^16.2.0",
                 "@types/jest": "^29.5.13",
@@ -4436,6 +4437,20 @@
                 }
             }
         },
+        "node_modules/@testing-library/user-event": {
+            "version": "14.6.1",
+            "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.1.tgz",
+            "integrity": "sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">=12",
+                "npm": ">=6"
+            },
+            "peerDependencies": {
+                "@testing-library/dom": ">=7.21.4"
+            }
+        },
         "node_modules/@tootallnate/once": {
             "version": "2.0.0",
             "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-2.0.0.tgz",

client/package.json

@@ -47,6 +47,7 @@
         "@babel/preset-typescript": "^7.23.3",
         "@eslint/js": "^9.21.0",
         "@testing-library/dom": "^10.4.0",
+        "@testing-library/user-event": "^14.6.1",
         "@testing-library/jest-dom": "^6.6.3",
         "@testing-library/react": "^16.2.0",
         "@types/jest": "^29.5.13",

client/src/Types/ImageType.tsx

@@ -0,0 +1,17 @@
+export interface ImageType {
+    id: string;
+    file_content: string;
+    file_name: string;
+    mime_type: string;
+}
+
+export interface ImagesResponse {
+    images: ImageType[];
+    total: number;
+}
+
+export interface ImagesParams {
+    page: number;
+    limit: number;
+    uid?: string;
+}

client/src/Types/Images.tsx

@@ -0,0 +1,17 @@
+export interface Images {
+    id: string;
+    file_content: string;
+    file_name: string;
+    mime_type: string;
+}
+
+export interface ImagesResponse {
+    images: Images[];
+    total: number;
+}
+
+export interface ImagesParams {
+    page: number;
+    limit: number;
+    uid?: string;
+}

client/src/__tests__/components/ImageGallery/ImageGallery.test.tsx

@@ -0,0 +1,91 @@
+import React, { act } from "react";
+import { render, screen, fireEvent, waitFor } from "@testing-library/react";
+import ImageGallery from "../../../components/ImageGallery/ImageGallery";
+import ApiService from "../../../services/ApiService";
+import { Images } from "../../../Types/Images";
+import "@testing-library/jest-dom";
+
+jest.mock("../../../services/ApiService");
+
+const mockImages: Images[] = [
+  { id: "1", file_name: "image1.jpg", mime_type: "image/jpeg", file_content: "mockBase64Content1" },
+  { id: "2", file_name: "image2.jpg", mime_type: "image/jpeg", file_content: "mockBase64Content2" },
+  { id: "3", file_name: "image3.jpg", mime_type: "image/jpeg", file_content: "mockBase64Content3" },
+];
+
+beforeAll(() => {
+  Object.assign(navigator, {
+    clipboard: {
+      writeText: jest.fn(),
+    },
+  });
+});
+
+describe("ImageGallery", () => {
+
+  let mockHandleDelete: jest.Mock;
+  beforeEach(() => {
+    (ApiService.getUserImages as jest.Mock).mockResolvedValue({ images: mockImages, total: 3 });
+    (ApiService.deleteImage as jest.Mock).mockResolvedValue(true); 
+    (ApiService.uploadImage as jest.Mock).mockResolvedValue('mockImageUrl'); 
+    mockHandleDelete = jest.fn();
+
+    render(<ImageGallery />);
+  });
+
+  it("should render images correctly", async () => {
+    await act(async () => {
+      await screen.findByText("Gallery");
+    });
+
+    expect(screen.getByAltText("Image image1.jpg")).toBeInTheDocument();
+    expect(screen.getByAltText("Image image2.jpg")).toBeInTheDocument();
+  });
+
+  it("should handle copy action", async () => {
+    const handleCopyMock = jest.fn();
+  
+    render(<ImageGallery handleCopy={handleCopyMock} />);
+
+    const copyButtons = await waitFor(() => screen.findAllByTestId(/gallery-tab-copy-/));
+    await act(async () => {
+      fireEvent.click(copyButtons[0]);
+    });
+  
+    expect(navigator.clipboard.writeText).toHaveBeenCalled();
+  });
+
+  it("should delete an image and update the gallery", async () => {
+    const fetchImagesMock = jest.fn().mockResolvedValue({ images: mockImages.filter((image) => image.id !== "1"), total: 2 });
+
+    (ApiService.getUserImages as jest.Mock).mockImplementation(fetchImagesMock);
+
+    render(<ImageGallery handleDelete={mockHandleDelete} />);
+
+    await act(async () => {
+      await screen.findByAltText("Image image1.jpg");
+    });
+
+    const deleteButtons = await waitFor(() => screen.findAllByTestId(/gallery-tab-delete-/));
+    fireEvent.click(deleteButtons[0]);
+    
+    await waitFor(() => {
+      expect(screen.getByText("Voulez-vous supprimer cette image?")).toBeInTheDocument();
+    });
+
+    const confirmDeleteButton = screen.getByText("Delete");  
+    await act(async () => {
+      fireEvent.click(confirmDeleteButton);
+    });
+
+    await waitFor(() => {
+      expect(ApiService.deleteImage).toHaveBeenCalledWith("1");
+    });
+
+    await waitFor(() => {
+      expect(screen.queryByAltText("Image image1.jpg")).toBeNull();
+      expect(screen.getByText("Image supprimée avec succès !")).toBeInTheDocument();
+    });
+  });
+
+});

client/src/components/ImageGallery/ImageGallery.tsx

@@ -0,0 +1,286 @@
+import React, { useState, useEffect } from "react";
+import {
+  Box,
+  CircularProgress,
+  Button,
+  IconButton,
+  Card,
+  CardContent,
+  Dialog,
+  DialogContent,
+  DialogActions,
+  DialogTitle,
+  DialogContentText,
+  Tabs,
+  Tab,
+  TextField, Snackbar,
+  Alert
+} from "@mui/material";
+import DeleteIcon from "@mui/icons-material/Delete";
+import ContentCopyIcon from "@mui/icons-material/ContentCopy";
+import CloseIcon from "@mui/icons-material/Close";
+import { ImageType } from "../../Types/ImageType";
+import ApiService from "../../services/ApiService";
+import { Upload } from "@mui/icons-material";
+
+interface ImagesProps {
+  handleCopy?: (id: string) => void;
+  handleDelete?: (id: string) => void;
+}
+
+const ImageGallery: React.FC<ImagesProps> = ({ handleCopy, handleDelete }) => {
+  const [images, setImages] = useState<ImageType[]>([]);
+  const [totalImg, setTotalImg] = useState(0);
+  const [imgPage, setImgPage] = useState(1);
+  const [imgLimit] = useState(6);
+  const [loading, setLoading] = useState(false);
+  const [selectedImage, setSelectedImage] = useState<ImageType | null>(null);
+  const [openDeleteDialog, setOpenDeleteDialog] = useState(false);
+  const [imageToDelete, setImageToDelete] = useState<ImageType | null>(null);
+  const [tabValue, setTabValue] = useState(0);
+  const [importedImage, setImportedImage] = useState<File | null>(null);
+  const [preview, setPreview] = useState<string | null>(null);
+  const [snackbarOpen, setSnackbarOpen] = useState(false);
+  const [snackbarMessage, setSnackbarMessage] = useState("");
+  const [snackbarSeverity, setSnackbarSeverity] = useState<"success" | "error">("success");
+
+  const fetchImages = async () => {
+    setLoading(true);
+    const data = await ApiService.getUserImages(imgPage, imgLimit);
+    setImages(data.images);
+    setTotalImg(data.total);
+    setLoading(false);
+  };
+
+  useEffect(() => {
+    fetchImages();
+  }, [imgPage]);
+
+  const defaultHandleDelete = async (id: string) => {
+    if (imageToDelete) {
+      setLoading(true);
+      const isDeleted = await ApiService.deleteImage(id);
+      setLoading(false);
+
+      if (isDeleted) {
+        //setImages(images.filter((image) => image.id !== id));
+        setImgPage(1);
+        fetchImages();
+        setSnackbarMessage("Image supprimée avec succès !");
+        setSnackbarSeverity("success");
+      } else {
+        setSnackbarMessage("Erreur lors de la suppression de l'image. Veuillez réessayer.");
+        setSnackbarSeverity("error");
+      }
+
+      setSnackbarOpen(true);
+      setSelectedImage(null);
+      setImageToDelete(null);
+      setOpenDeleteDialog(false);
+    }
+  };
+
+  const defaultHandleCopy = (id: string) => {
+    if (navigator.clipboard) {
+      navigator.clipboard.writeText(id);
+    }
+  };
+
+  const handleCopyFunction = handleCopy || defaultHandleCopy;
+  const handleDeleteFunction = handleDelete || defaultHandleDelete;
+
+  const handleImageUpload = (event: React.ChangeEvent<HTMLInputElement>) => {
+    const file = event.target.files ? event.target.files[0] : null;
+    setImportedImage(file);
+    if (file) {
+      const objectUrl = URL.createObjectURL(file);
+      setPreview(objectUrl);
+    }
+  };
+
+  const handleSaveImage = async () => {
+    try {
+      if (!importedImage) {
+        setSnackbarMessage("Veuillez d'abord choisir une image à téléverser.");
+        setSnackbarSeverity("error");
+        setSnackbarOpen(true);
+        return;
+      }
+
+      const imageUrl = await ApiService.uploadImage(importedImage);
+
+      if (imageUrl.includes("ERROR")) {
+        setSnackbarMessage("Une erreur est survenue. Veuillez réessayer plus tard.");
+        setSnackbarSeverity("error");
+        setSnackbarOpen(true);
+        return;
+      }
+      fetchImages();
+
+      setSnackbarMessage("Téléversée avec succès !");
+      setSnackbarSeverity("success");
+      setSnackbarOpen(true);
+
+      // Reset the input field and preview after successful upload
+      setImportedImage(null);
+      setPreview(null);
+    } catch (error) {
+      setSnackbarMessage(`Une erreur est survenue.\n${error}\nVeuillez réessayer plus tard.`);
+      setSnackbarSeverity("error");
+      setSnackbarOpen(true);
+    }
+  };
+
+  return (
+    <Box p={3}>
+      <Tabs value={tabValue} onChange={(_, newValue) => setTabValue(newValue)}>
+        <Tab label="Gallery" />
+        <Tab label="Import" />
+      </Tabs>
+      {tabValue === 0 && (
+        <>
+          {loading ? (
+            <Box display="flex" justifyContent="center" alignItems="center" height={200}>
+              <CircularProgress />
+            </Box>
+          ) : (
+            <>
+              <Box display="grid" gridTemplateColumns="repeat(3, 1fr)" gridTemplateRows="repeat(2, 1fr)" gap={2} maxWidth="900px" margin="auto">
+                {images.map((obj) => (
+                  <Card key={obj.id} sx={{ cursor: "pointer", display: "flex", flexDirection: "column", alignItems: "center" }} onClick={() => setSelectedImage(obj)}>
+                    <CardContent sx={{ p: 0 }}>
+                      <img
+                        src={`data:${obj.mime_type};base64,${obj.file_content}`}
+                        alt={`Image ${obj.file_name}`}
+                        style={{ width: "100%", height: 250, objectFit: "cover", borderRadius: 8 }}
+                      />
+                    </CardContent>
+                    <Box display="flex" justifyContent="center" mt={1}>
+                      <IconButton onClick={(e) => {
+                        e.stopPropagation();
+                        handleCopyFunction(obj.id);
+                        }} 
+                        color="primary"
+                        data-testid={`gallery-tab-copy-${obj.id}`} >
+                        
+                        <ContentCopyIcon sx={{ fontSize: 18 }} />
+                      </IconButton>
+
+                      <IconButton
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          setImageToDelete(obj);
+                          setOpenDeleteDialog(true);
+                        }}
+                        color="error"
+                        data-testid={`gallery-tab-delete-${obj.id}`}  >
+
+                        <DeleteIcon sx={{ fontSize: 18 }} />
+                      </IconButton>
+                    </Box>
+                  </Card>
+                ))}
+              </Box>
+              <Box display="flex" justifyContent="center" mt={2}>
+                <Button onClick={() => setImgPage((prev) => Math.max(prev - 1, 1))} disabled={imgPage === 1} color="primary">
+                  Précédent
+                </Button>
+                <Button onClick={() => setImgPage((prev) => (prev * imgLimit < totalImg ? prev + 1 : prev))} disabled={imgPage * imgLimit >= totalImg} color="primary">
+                  Suivant
+                </Button>
+              </Box>
+            </>
+          )}
+        </>
+      )}
+      {tabValue === 1 && (
+        <Box display="flex" flexDirection="column" alignItems="center" width="100%" mt={3}>
+          {/* Image Preview at the top */}
+          {preview && (
+            <Box
+              mt={2}
+              mb={2}
+              sx={{
+                width: "100%",
+                maxWidth: 600,
+                textAlign: "center",
+                display: "flex",
+                justifyContent: "center",
+                alignItems: "center",
+              }}
+            >
+              <img
+                src={preview}
+                alt="Preview"
+                style={{
+                  width: "100%",
+                  height: "auto",
+                  borderRadius: 8,
+                  maxHeight: "600px", 
+                }}
+              />
+            </Box>
+          )}
+          <Box display="flex" flexDirection="row" alignItems="center" width="100%" maxWidth={400}>
+            <TextField
+              type="file"
+              onChange={handleImageUpload}  
+              slotProps={{
+                htmlInput: {
+                  accept: "image/*",
+                },
+              }}
+              sx={{ flexGrow: 1 }}
+            />
+            <Button
+              variant="outlined"
+              aria-label="Téléverser"
+              onClick={() => { handleSaveImage() }}
+              sx={{ ml: 2, height: "100%" }} 
+            >
+              Téléverser <Upload sx={{ ml: 1 }} />
+            </Button>
+          </Box>    
+        </Box>
+      )}
+      <Dialog open={!!selectedImage} onClose={() => setSelectedImage(null)} maxWidth="md">
+        <IconButton color="primary" onClick={() => setSelectedImage(null)} sx={{ position: "absolute", right: 8, top: 8, zIndex: 1 }}>
+          <CloseIcon />
+        </IconButton>
+        <DialogContent>
+          {selectedImage && (
+            <img
+              src={`data:${selectedImage.mime_type};base64,${selectedImage.file_content}`}
+              alt="Enlarged view"
+              style={{ width: "100%", height: "auto", borderRadius: 8, maxHeight: "500px" }}
+            />
+          )}
+        </DialogContent>
+      </Dialog>
+
+      {/* Delete Confirmation Dialog */}
+      <Dialog open={openDeleteDialog} onClose={() => setOpenDeleteDialog(false)}>
+        <DialogTitle>Supprimer</DialogTitle>
+        <DialogContent>
+          <DialogContentText>Voulez-vous supprimer cette image?</DialogContentText>
+        </DialogContent>
+        <DialogActions>
+          <Button onClick={() => setOpenDeleteDialog(false)} color="primary">
+            Annuler
+          </Button>
+          <Button onClick={() => imageToDelete && handleDeleteFunction(imageToDelete.id)} color="error">
+            Delete
+          </Button>
+        </DialogActions>
+      </Dialog>
+
+      <Snackbar open={snackbarOpen} autoHideDuration={4000} onClose={() => setSnackbarOpen(false)}>
+        <Alert onClose={() => setSnackbarOpen(false)} severity={snackbarSeverity} sx={{ width: "100%" }}>
+          {snackbarMessage}
+        </Alert>
+      </Snackbar>
+    </Box>
+  );
+};
+
+export default ImageGallery;

client/src/components/ImageGallery/ImageGalleryModal/ImageGalleryModal.tsx

@@ -0,0 +1,54 @@
+import React, { useState } from "react";
+import {
+  Button,
+  IconButton,
+  Dialog,
+  DialogContent,
+} from "@mui/material";
+import CloseIcon from "@mui/icons-material/Close";
+import ImageGallery from "../ImageGallery";
+import { ImageSearch } from "@mui/icons-material";
+
+
+interface ImageGalleryModalProps {
+  handleCopy?: (id: string) => void;
+}
+
+
+const ImageGalleryModal: React.FC<ImageGalleryModalProps> = ({ handleCopy }) => {
+  const [open, setOpen] = useState<boolean>(false);
+
+  const handleOpen = () => setOpen(true);
+  const handleClose = () => setOpen(false);
+
+  return (
+    <>
+      <Button
+        variant="outlined"
+        aria-label='Téléverser'
+        onClick={() => handleOpen()}>
+        Images <ImageSearch /> 
+      </Button>    
+      <Dialog open={open} onClose={handleClose} maxWidth="md" fullWidth>
+        <DialogContent sx={{ display: "flex", flexDirection: "column", alignItems: "center", py: 3 }}>
+          <IconButton
+            onClick={handleClose}
+            color="primary"
+            sx={{
+              position: "absolute",
+              right: 8,
+              top: 8,
+              zIndex: 1,
+            }}
+          >
+            <CloseIcon />
+          </IconButton>
+
+          <ImageGallery handleCopy={handleCopy}/>
+        </DialogContent>
+      </Dialog>
+    </>
+  );
+};
+
+export default ImageGalleryModal;

client/src/constants.tsx

@@ -2,6 +2,7 @@
 const ENV_VARIABLES = {
     MODE: process.env.MODE || "production",
     VITE_BACKEND_URL: process.env.VITE_BACKEND_URL || "",
+    IMG_URL: process.env.MODE == "development" ? process.env.VITE_BACKEND_URL : process.env.IMG_URL,
     BACKEND_URL: process.env.SITE_URL != undefined ? `${process.env.SITE_URL}${process.env.USE_PORTS ? `:${process.env.BACKEND_PORT}`:''}` : process.env.VITE_BACKEND_URL || '',
     FRONTEND_URL: process.env.SITE_URL != undefined ? `${process.env.SITE_URL}${process.env.USE_PORTS ? `:${process.env.PORT}`:''}` : ''
 };

client/src/pages/Teacher/EditorQuiz/EditorQuiz.tsx

@@ -1,5 +1,5 @@
 // EditorQuiz.tsx
-import React, { useState, useEffect, useRef, CSSProperties } from 'react';
+import React, { useState, useEffect, CSSProperties } from 'react';
 import { useParams, useNavigate } from 'react-router-dom';
 
 import { FolderType } from '../../../Types/FolderType';
@@ -11,12 +11,13 @@ import GIFTTemplatePreview from 'src/components/GiftTemplate/GIFTTemplatePreview
 import { QuizType } from '../../../Types/QuizType';
 
 import './editorQuiz.css';
-import { Button, TextField, NativeSelect, Divider, Dialog, DialogTitle, DialogActions, DialogContent } from '@mui/material';
+import { Button, TextField, NativeSelect, Divider } from '@mui/material';
 import ReturnButton from 'src/components/ReturnButton/ReturnButton';
+import ImageGalleryModal from 'src/components/ImageGallery/ImageGalleryModal/ImageGalleryModal';
 
 import ApiService from '../../../services/ApiService';
 import { escapeForGIFT } from '../../../utils/giftUtils';
-import { Upload } from '@mui/icons-material';
+import { ENV_VARIABLES } from '../../../constants';
 
 interface EditQuizParams {
     id: string;
@@ -38,8 +39,6 @@ const QuizForm: React.FC = () => {
     const handleSelectFolder = (event: React.ChangeEvent<HTMLSelectElement>) => {
         setSelectedFolder(event.target.value);
     };
-    const fileInputRef = useRef<HTMLInputElement>(null);
-    const [dialogOpen, setDialogOpen] = useState(false);
     const [showScrollButton, setShowScrollButton] = useState(false);
 
     const scrollToTop = () => {
@@ -166,44 +165,16 @@ const QuizForm: React.FC = () => {
         return <div>Chargement...</div>;
     }
 
-    const handleSaveImage = async () => {
-        try {
-            const inputElement = document.getElementById('file-input') as HTMLInputElement;
-
-            if (!inputElement?.files || inputElement.files.length === 0) {
-                setDialogOpen(true);
-                return;
-            }
-
-            if (!inputElement.files || inputElement.files.length === 0) {
-                window.alert("Veuillez d'abord choisir une image à téléverser.")
-                return;
-            }
-
-            const imageUrl = await ApiService.uploadImage(inputElement.files[0]);
-
-            // Check for errors
-            if(imageUrl.indexOf("ERROR") >= 0) {
-                window.alert(`Une erreur est survenue.\n Veuillez réessayer plus tard`)
-                return;
-            }
-
-            setImageLinks(prevLinks => [...prevLinks, imageUrl]);
-
-            // Reset the file input element
-            if (fileInputRef.current) {
-                fileInputRef.current.value = '';
-            }
-        } catch (error) {
-            window.alert(`Une erreur est survenue.\n${error}\nVeuillez réessayer plus tard.`)
-
-        }
-    };
-
     const handleCopyToClipboard = async (link: string) => {
         navigator.clipboard.writeText(link);
     }
 
+    const handleCopyImage = (id: string) => {
+        const escLink = `${ENV_VARIABLES.IMG_URL}/api/image/get/${id}`;
+        navigator.clipboard.writeText(id);
+        setImageLinks(prevLinks => [...prevLinks, escLink]);
+    }
+
     return (
         <div className='quizEditor'>
 
@@ -258,37 +229,11 @@ const QuizForm: React.FC = () => {
                         onEditorChange={handleUpdatePreview} />
 
                     <div className='images'>
-                        <div className='upload'>
-                            <label className="dropArea">
-                                <input type="file" id="file-input" className="file-input"
-                                accept="image/jpeg, image/png"
-                                multiple 
-                                ref={fileInputRef} />
-
-                                <Button
-                                variant="outlined"
-                                aria-label='Téléverser'
-                                onClick={handleSaveImage}>
-                                    Téléverser <Upload /> 
-                                </Button>
-
-                            </label>
-                            <Dialog
-                                open={dialogOpen}
-                                onClose={() => setDialogOpen(false)} >
-                                <DialogTitle>Erreur</DialogTitle>
-                                <DialogContent>
-                                    Veuillez d&apos;abord choisir une image à téléverser.
-                                </DialogContent>
-                                <DialogActions>
-                                    <Button onClick={() => setDialogOpen(false)} color="primary">
-                                        OK
-                                    </Button>
-                                </DialogActions>
-                            </Dialog>
+                        <div style={{ display: 'flex', alignItems: 'center', gap: '10px' }}>
+                            <h4>Mes images :</h4>
+                                <ImageGalleryModal handleCopy={handleCopyImage} />
                         </div>
-
-                        <h4>Mes images :</h4>
+                                
                         <div>
                                 <div>
                                 <div style={{ display: "inline" }}>(Voir section </div>
@@ -302,7 +247,7 @@ const QuizForm: React.FC = () => {
                                 </div>                            
                                 <ul>
                                 {imageLinks.map((link, index) => {
-                                    const imgTag = `![alt_text](${escapeForGIFT(link)} "texte de l'infobulle")`;
+                                    const imgTag = `[markdown]![alt_text](${escapeForGIFT(link)} "texte de l'infobulle") {T}`;
                                     return (
                                         <li key={index}>
                                             <code

client/src/services/ApiService.tsx

@@ -3,6 +3,7 @@ import { jwtDecode } from 'jwt-decode';
 import { ENV_VARIABLES } from '../constants';
 
 import { FolderType } from 'src/Types/FolderType';
+import { ImagesResponse, ImagesParams } from '../Types/Images';
 import { QuizType } from 'src/Types/QuizType';
 import { RoomType } from 'src/Types/RoomType';
 
@@ -142,6 +143,22 @@ class ApiService {
         return object.username;
     }
 
+    public getUserID(): string {
+        const token = localStorage.getItem("jwt");
+        
+        if (!token) {
+            return "";
+        }
+
+        const jsonObj = jwtDecode(token) as { userId: string };
+        
+        if (!jsonObj.userId) {
+            return "";
+        }
+
+        return jsonObj.userId;
+    }
+
     // Route to know if rooms need authentication to join
     public async getRoomsRequireAuth(): Promise<any> {
         const url: string = this.constructRequestUrl(`/auth/getRoomsRequireAuth`);
@@ -1167,7 +1184,99 @@ public async login(email: string, password: string): Promise<any> {
             return `ERROR : Une erreur inattendue s'est produite.`
         }
     }
-    // NOTE : Get Image pas necessaire
+
+    public async getImages(page: number, limit: number): Promise<ImagesResponse> {
+        try {
+            const url: string = this.constructRequestUrl(`/image/getImages`);
+            const headers = this.constructRequestHeaders();
+            let params : ImagesParams = { page: page, limit: limit };
+
+            const result: AxiosResponse = await axios.get(url, { params: params, headers: headers });
+
+            if (result.status !== 200) {
+                throw new Error(`L'affichage des images a échoué. Status: ${result.status}`);
+            }
+            const images = result.data;
+
+            return images;
+
+        } catch (error) {
+            console.log("Error details: ", error);
+
+            if (axios.isAxiosError(error)) {
+                const err = error as AxiosError;
+                const data = err.response?.data as { error: string } | undefined;
+                const msg = data?.error || 'Erreur serveur inconnue lors de la requête.';
+                throw new Error(`L'enregistrement a échoué. Status: ${msg}`);
+            }
+
+            throw new Error(`ERROR : Une erreur inattendue s'est produite.`);
+        }
+    }
+
+    public async getUserImages(page: number, limit: number): Promise<ImagesResponse> {
+        try {
+            const url: string = this.constructRequestUrl(`/image/getUserImages`);
+            const headers = this.constructRequestHeaders();
+            let params : ImagesParams = { page: page, limit: limit };
+
+            const uid = this.getUserID();
+            if(uid !== ''){
+                params.uid = uid;
+            }
+
+            const result: AxiosResponse = await axios.get(url, { params: params, headers: headers });
+
+            if (result.status !== 200) {
+                throw new Error(`L'affichage des images de l'utilisateur a échoué. Status: ${result.status}`);
+            }
+            const images = result.data;
+
+            return images;
+
+        } catch (error) {
+            console.log("Error details: ", error);
+
+            if (axios.isAxiosError(error)) {
+                const err = error as AxiosError;
+                const data = err.response?.data as { error: string } | undefined;
+                const msg = data?.error || 'Erreur serveur inconnue lors de la requête.';
+                throw new Error(`L'enregistrement a échoué. Status: ${msg}`);
+            }
+
+            throw new Error(`ERROR : Une erreur inattendue s'est produite.`);
+        }
+    }
+
+    public async deleteImage(imgId: string): Promise<ApiResponse> {
+        try {
+            const url: string = this.constructRequestUrl(`/image/delete`);
+            const headers = this.constructRequestHeaders();
+            const uid = this.getUserID();
+            let params = { uid: uid, imgId: imgId };
+
+            const result: AxiosResponse = await axios.delete(url, { params: params, headers: headers });
+
+            if (result.status !== 200) {
+                throw new Error(`La suppression de l'image a échoué. Status: ${result.status}`);
+            }
+
+            const deleted = result.data.deleted;
+            return deleted;
+
+        } catch (error) {
+            console.log("Error details: ", error);
+
+            if (axios.isAxiosError(error)) {
+                const err = error as AxiosError;
+                const data = err.response?.data as { error: string } | undefined;
+                const msg = data?.error || 'Erreur serveur inconnue lors de la requête.';
+                throw new Error(`L'enregistrement a échoué. Status: ${msg}`);
+            }
+
+            throw new Error(`ERROR : Une erreur inattendue s'est produite.`);
+        }
+    }
 
 }
 

docker-compose-local.yaml

@@ -7,6 +7,8 @@ services:
       context: ./client
       dockerfile: Dockerfile
     container_name: frontend
+    environment:
+      VITE_IMG_URL: http://localhost
     ports:
       - "5173:5173"
     restart: always
@@ -54,7 +56,7 @@ services:
     image: mongo
     container_name: mongo
     ports:
-      - "27017:27017"
+      - "27019:27017"
     tty: true
     volumes:
       - mongodb_data:/data/db

docker-compose.yaml

@@ -10,6 +10,7 @@ services:
       - VITE_BACKEND_URL=
       # Define empty VITE_BACKEND_SOCKET_URL so it will default to window.location.host
       - VITE_BACKEND_SOCKET_URL=
+      - VITE_IMG_URL=https://evalsa.etsmtl.ca
     ports:
       - "5173:5173"
     restart: always

server/__tests__/image.test.js

@@ -7,6 +7,9 @@
 
 // const BASE_URL = '/image'
 
+const Images = require('../models/images');
+const ObjectId = require('mongodb').ObjectId;
+
 describe.skip("POST /upload", () => {
 
     describe("when the jwt is not sent", () => {
@@ -64,3 +67,289 @@ describe.skip("GET /get", () => {
     })
 
 })
+
+jest.mock('mongodb', () => {
+    const originalModule = jest.requireActual('mongodb');
+    return {
+        ...originalModule,
+        ObjectId: {
+            ...originalModule.ObjectId,
+            createFromHexString: jest.fn().mockReturnValue('507f191e810c19729de860ea'), // Return a valid 24-character ObjectId string
+        },
+    };
+});
+
+describe('Images', () => {
+    let db;
+    let images;
+    let dbConn;
+    let mockImagesCollection;
+    let mockFindCursor;
+
+    beforeEach(() => {
+            
+    const mockImagesCursor = {
+        sort: jest.fn().mockReturnThis(),
+        skip: jest.fn().mockReturnThis(),
+        limit: jest.fn().mockReturnThis(),
+        toArray: jest.fn()
+    };
+
+    const mockFilesCursor = {
+        sort: jest.fn().mockReturnThis(),
+        skip: jest.fn().mockReturnThis(),
+        limit: jest.fn().mockReturnThis(),
+        toArray: jest.fn()
+    };
+
+        mockImagesCollection = {
+            insertOne: jest.fn().mockResolvedValue({ insertedId: 'image123' }),
+            findOne: jest.fn(),
+            find: jest.fn().mockReturnValue(mockImagesCursor),
+            countDocuments: jest.fn(),
+            deleteOne: jest.fn()
+        };
+
+        mockFilesCollection = {
+            find: jest.fn().mockReturnValue(mockFilesCursor)
+        };
+        
+        dbConn = {
+            collection: jest.fn((name) => {
+                if (name === 'images') {
+                    return mockImagesCollection;
+                } else if (name === 'files') {
+                    return mockFilesCollection;
+                }
+            })
+        };
+
+        db = {
+            connect: jest.fn().mockResolvedValue(),
+            getConnection: jest.fn().mockReturnValue(dbConn)
+        };
+
+        images = new Images(db);
+    });
+
+    describe('upload', () => {
+        it('should upload an image and return the inserted ID', async () => {
+            const testFile = { originalname: 'test.png', buffer: Buffer.from('dummydata'), mimetype: 'image/png' };
+            const userId = 'user123';
+
+            const result = await images.upload(testFile, userId);
+
+            expect(db.connect).toHaveBeenCalled();
+            expect(db.getConnection).toHaveBeenCalled();
+            expect(dbConn.collection).toHaveBeenCalledWith('images');
+            expect(mockImagesCollection.insertOne).toHaveBeenCalledWith({
+                userId: userId,
+                file_name: 'test.png',
+                file_content: testFile.buffer.toString('base64'),
+                mime_type: 'image/png',
+                created_at: expect.any(Date)
+            });
+            expect(result).toBe('image123');
+        });
+    });
+
+    describe('get', () => {
+        it('should retrieve the image if found', async () => {
+            const imageId = '65d9a8f9b5e8d1a5e6a8c9f0';
+            const testImage = {
+                file_name: 'test.png',
+                file_content: Buffer.from('dummydata').toString('base64'),
+                mime_type: 'image/png'
+            };
+            mockImagesCollection.findOne.mockResolvedValue(testImage);
+
+            const result = await images.get(imageId);
+
+            expect(db.connect).toHaveBeenCalled();
+            expect(db.getConnection).toHaveBeenCalled();
+            expect(dbConn.collection).toHaveBeenCalledWith('images');
+            expect(mockImagesCollection.findOne).toHaveBeenCalledWith({ _id: ObjectId.createFromHexString(imageId) });
+            expect(result).toEqual({
+                file_name: 'test.png',
+                file_content: Buffer.from('dummydata'),
+                mime_type: 'image/png'
+            });
+        });
+
+        it('should return null if image is not found', async () => {
+            const imageId = '65d9a8f9b5e8d1a5e6a8c9f0';
+            mockImagesCollection.findOne.mockResolvedValue(null);
+
+            const result = await images.get(imageId);
+
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('getImages', () => {
+        it('should retrieve a paginated list of images', async () => {
+            const mockImages = [
+                { _id: '1', userId: 'user1', file_name: 'image1.png', file_content: Buffer.from('data1'), mime_type: 'image/png' },
+                { _id: '2', userId: 'user2', file_name: 'image2.png', file_content: Buffer.from('data2'), mime_type: 'image/png' }
+            ];
+    
+            mockImagesCollection.countDocuments.mockResolvedValue(2);
+            // Create a mock cursor for images collection
+            const mockFindCursor = {
+                sort: jest.fn().mockReturnThis(),
+                skip: jest.fn().mockReturnThis(),
+                limit: jest.fn().mockReturnThis(),
+                toArray: jest.fn().mockResolvedValue(mockImages),  // Return mock images when toArray is called
+            };
+    
+            // Mock the find method to return the mock cursor
+            mockImagesCollection.find.mockReturnValue(mockFindCursor);
+            const result = await images.getImages(1, 10);
+    
+            expect(db.connect).toHaveBeenCalled();
+            expect(db.getConnection).toHaveBeenCalled();
+            expect(dbConn.collection).toHaveBeenCalledWith('images');
+            expect(mockImagesCollection.find).toHaveBeenCalledWith({});
+            expect(mockFindCursor.sort).toHaveBeenCalledWith({ created_at: 1 });
+            expect(mockFindCursor.skip).toHaveBeenCalledWith(0);
+            expect(mockFindCursor.limit).toHaveBeenCalledWith(10);
+            expect(result).toEqual({
+                images: [
+                    { id: '1', user: 'user1', file_name: 'image1.png', file_content: 'ZGF0YTE=', mime_type: 'image/png' },
+                    { id: '2', user: 'user2', file_name: 'image2.png', file_content: 'ZGF0YTI=', mime_type: 'image/png' }
+                ],
+                total: 2,
+            });
+        });
+    
+        it('should return an empty array if no images are found', async () => {
+            mockImagesCollection.countDocuments.mockResolvedValue(0);
+    
+            const result = await images.getImages(1, 10);
+    
+            expect(result).toEqual({ images: [], total: 0 });
+        });
+    });
+
+    describe('getUserImages', () => {
+        it('should return empty images array when no images exist', async () => {
+            mockImagesCollection.countDocuments.mockResolvedValue(0);
+            
+            const result = await images.getUserImages(1, 10, 'user123');
+            
+            expect(result).toEqual({ images: [], total: 0 });
+            expect(db.connect).toHaveBeenCalled();
+            expect(mockImagesCollection.countDocuments).toHaveBeenCalledWith({ userId: 'user123' });
+        });
+
+        it('should return images when they exist', async () => {
+            const mockImages = [
+                {
+                    _id: 'img1',
+                    userId: 'user123',
+                    file_name: 'image1.png',
+                    file_content: Buffer.from('testdata'),
+                    mime_type: 'image/png'
+                }
+            ];
+
+            mockImagesCollection.countDocuments.mockResolvedValue(1);
+            mockImagesCollection.find.mockReturnValue({
+                sort: jest.fn().mockReturnThis(),
+                skip: jest.fn().mockReturnThis(),
+                limit: jest.fn().mockReturnThis(),
+                toArray: jest.fn().mockResolvedValue(mockImages)
+            });
+
+            const result = await images.getUserImages(1, 10, 'user123');
+            
+            expect(result).toEqual({
+                images: [
+                    {
+                        id: 'img1',
+                        user: 'user123',
+                        file_name: 'image1.png',
+                        file_content: Buffer.from('testdata').toString('base64'),
+                        mime_type: 'image/png'
+                    }
+                ],
+                total: 1
+            });
+            expect(db.connect).toHaveBeenCalled();
+            expect(mockImagesCollection.countDocuments).toHaveBeenCalledWith({ userId: 'user123' });
+        });
+    });
+    describe('delete', () => {
+        it('should not delete the image when it exists in the files collection', async () => {
+            const uid = 'user123';
+            const imgId = '507f191e810c19729de860ea';  // A valid 24-character ObjectId string
+
+            // Mock the files collection cursor to simulate an image found
+            const mockFilesCursor = {
+                toArray: jest.fn().mockResolvedValue([{ _id: imgId }])  // Image found
+            };
+
+            mockFilesCollection.find.mockReturnValue(mockFilesCursor);
+            mockImagesCollection.deleteOne.mockResolvedValue({ deletedCount: 0 });
+
+            const result = await images.delete(uid, imgId);
+
+            // Ensure the files collection is queried
+            expect(dbConn.collection).toHaveBeenCalledWith('files');
+            expect(mockFilesCollection.find).toHaveBeenCalledWith({
+                userId: uid,
+                content: { $regex: new RegExp(`/api/image/get/${imgId}`) },
+            });
+
+            // Ensure the images collection is queried for deletion
+            expect(dbConn.collection).toHaveBeenCalledWith('files');
+            expect(mockImagesCollection.deleteOne).not.toHaveBeenCalledWith({
+                _id: ObjectId.createFromHexString(imgId), // Ensure the ObjectId is created correctly
+            });
+
+            expect(result).toEqual({ deleted: false });
+        });
+
+        it('should delete the image if not found in the files collection', async () => {
+            const uid = 'user123';
+            const imgId = '507f191e810c19729de860ea';
+
+            // Mock the files collection cursor to simulate the image not being found
+            const mockFindCursor = {
+                toArray: jest.fn().mockResolvedValue([])  // Empty array means image not found
+            };
+
+            mockFilesCollection.find.mockReturnValue(mockFindCursor);
+            mockImagesCollection.deleteOne.mockResolvedValue({ deletedCount: 1 });
+
+            const result = await images.delete(uid, imgId);
+
+            // Ensure the deleteOne is not called if the image is not found
+            expect(mockImagesCollection.deleteOne).toHaveBeenCalled();
+            expect(result).toEqual({ deleted: true });
+        });
+
+        it('should return false if the delete operation fails in the images collection', async () => {
+            const uid = 'user123';
+            const imgId = '507f191e810c19729de860ea';
+
+            // Mock the files collection cursor to simulate the image being found
+            const mockFindCursor = {
+                toArray: jest.fn().mockResolvedValue([{ _id: imgId }])  // Image found
+            };
+
+            mockFilesCollection.find.mockReturnValue(mockFindCursor);
+            mockImagesCollection.deleteOne.mockResolvedValue({ deletedCount: 0 });  // Simulate failure
+
+            const result = await images.delete(uid, imgId);
+
+            // Ensure the images collection deletion is called
+            expect(mockImagesCollection.deleteOne).not.toHaveBeenCalledWith({
+                _id: ObjectId.createFromHexString(imgId),  // Ensure the ObjectId is created correctly
+            });
+
+            expect(result).toEqual({ deleted: false });
+        });
+        
+    });
+});

server/controllers/images.js

@@ -50,6 +50,58 @@ class ImagesController {
         }
     };
 
+    getImages = async (req, res, next) => {
+        try {
+            const page = parseInt(req.query.page) || 1;
+            const limit = parseInt(req.query.limit) || 5;
+            const images = await this.images.getImages(page, limit);
+
+            if (!images || images.length === 0) {
+                throw new AppError(IMAGE_NOT_FOUND);
+            }
+            
+            res.setHeader('Content-Type', 'application/json');
+            return res.status(200).json(images);
+        } catch (error) {
+            return next(error);
+        }
+    };
+
+    getUserImages = async (req, res, next) => {
+        try {
+            const page = parseInt(req.query.page) || 1;
+            const limit = parseInt(req.query.limit) || 5;
+            const uid = req.query.uid;
+            const images = await this.images.getUserImages(page, limit, uid);
+    
+            if (!images || images.length === 0) {
+                throw new AppError(IMAGE_NOT_FOUND);
+            }
+            
+            res.setHeader('Content-Type', 'application/json');
+            return res.status(200).json(images);
+        } catch (error) {
+            return next(error);
+        }
+    };
+
+    delete = async (req, res, next) => {
+        try {
+            const uid = req.query.uid;
+            const imgId = req.query.imgId;
+            
+            if (!uid || !imgId) {
+                throw new AppError(MISSING_REQUIRED_PARAMETER);
+            }
+            const images = await this.images.delete(uid, imgId);
+            
+            res.setHeader('Content-Type', 'application/json');
+            return res.status(200).json(images);
+        } catch (error) {
+            return next(error);
+        }
+    };
+
 }
 
 module.exports = ImagesController;

server/models/images.js

@@ -42,6 +42,84 @@ class Images {
         };
     }
 
+    async getImages(page, limit) {
+        await this.db.connect()
+        const conn = this.db.getConnection();
+
+        const imagesCollection = conn.collection('images');
+
+        
+        const total = await imagesCollection.countDocuments();
+        if (!total || total === 0) return { images: [], total };
+
+        const result = await imagesCollection.find({})
+        .sort({ created_at: 1 })
+        .skip((page - 1) * limit)
+        .limit(limit)
+        .toArray();
+
+        const objImages = result.map(image => ({
+            id: image._id,
+            user: image.userId,
+            file_name: image.file_name,
+            file_content: image.file_content.toString('base64'),
+            mime_type: image.mime_type
+        }));
+
+        let respObj = {
+            images: objImages,
+            total: total
+        }
+
+        return respObj;
+    }
+
+    async getUserImages(page, limit, uid) {
+        await this.db.connect()
+        const conn = this.db.getConnection();
+        const imagesCollection = conn.collection('images');
+        const total = await imagesCollection.countDocuments({ userId: uid });
+        if (!total || total === 0) return { images: [], total };
+
+        const result = await imagesCollection.find({ userId: uid })
+        .sort({ created_at: 1 })
+        .skip((page - 1) * limit)
+        .limit(limit)
+        .toArray();
+
+        const objImages = result.map(image => ({
+            id: image._id,
+            user: image.userId,
+            file_name: image.file_name,
+            file_content: image.file_content.toString('base64'),
+            mime_type: image.mime_type
+        }));
+
+        let respObj = {
+            images: objImages,
+            total: total
+        }
+
+        return respObj;
+    }
+
+    async delete(uid, imgId) {
+        let resp = false;
+        await this.db.connect()
+        const conn = this.db.getConnection();
+        const quizColl = conn.collection('files');
+        const rgxImg = new RegExp(`/api/image/get/${imgId}`);
+        
+        const result = await quizColl.find({ userId: uid, content: { $regex: rgxImg }}).toArray();
+        if(!result || result.length < 1){
+            const imgsColl = conn.collection('images');
+            const isDeleted = await imgsColl.deleteOne({ _id: ObjectId.createFromHexString(imgId) });
+            if(isDeleted){
+                resp = true;
+            }
+        }
+        return { deleted: resp };
+    }
 }
 
 module.exports = Images;

server/routers/images.js

@@ -12,5 +12,8 @@ const upload = multer({ storage: storage });
 
 router.post("/upload", jwt.authenticate, upload.single('image'), asyncHandler(images.upload));
 router.get("/get/:id", asyncHandler(images.get));
+router.get("/getImages", asyncHandler(images.getImages));
+router.get("/getUserImages", asyncHandler(images.getUserImages));
+router.delete("/delete", asyncHandler(images.delete));
 
 module.exports = router;