File Tree : (After Completion of Assignment)

Hitarth Singh Rajput
LCS2023040

(See the page below)

Pasted image 20240331235852.png

Summary :

! Full Code is also provided later in this PDF

Post Method used :

@PostMapping("/user")
    ResponseEntity<?> uploadImage(@RequestParam("file") MultipartFile file, @RequestParam("userId") int userId) throws IOException {
    // ResponseEntity<?> uploadImage(@RequestParam("file") MultipartFile file, @PathParam("userId") int userId) throws IOException {
        apiReturnModel = new APIReturnModel();
        storeImageVec = new Vector<>();
        StoreImageModel storeImageModel = new StoreImageModel();
        storeImageModel.setOriginalName(file.getOriginalFilename());
        storeImageModel.setFileType(file.getContentType());
        storeImageModel.setUniqueName("profile_" + userId); // Generating a unique name for the file automatically based on the userId
        storeImageModel.setUser(this.userService.getUserById(userId));

        try {
            String filePath = profileImagesDirectory + "profile_" + userId;
            // Files.copy(file.getInputStream(), Paths.get(filePath), StandardCopyOption.REPLACE_EXISTING);
            byte[] fileData = FileUtils.compressFile(file.getBytes());
            Files.copy(new ByteArrayInputStream(fileData), Paths.get(filePath), StandardCopyOption.REPLACE_EXISTING);
            // Files.copy(file.getInputStream(), Paths.get(filePath), StandardCopyOption.REPLACE_EXISTING);

            StoreImageModel storeImageModel2 = this.storeImageService.uploadFile(storeImageModel);

            storeImageVec.add(storeImageModel2);
            apiReturnModel.setData(storeImageVec);
            apiReturnModel.setCount(storeImageVec.size());
            apiReturnModel.setMessage("File Uploaded Successfully !");
            apiReturnModel.setStatus("Success");
        } catch (Exception e) {
            apiReturnModel.setMessage("Something Went Wrong ! " + e.getMessage());
            // e.printStackTrace();
            apiReturnModel.setStatus("fail");
        }
        return ResponseEntity.ok(apiReturnModel);
    }

Get Method used :

 @GetMapping("/user/{userId}")
    ResponseEntity<?> getImage(@PathVariable("userId") int userId) {
        apiReturnModel = new APIReturnModel();
        storeImageVec = new Vector<>();
        byte[] imageBytes;
        try {
            StoreImageModel storeImageModel = this.storeImageService.downloadFile(userId);
            imageBytes = Files.readAllBytes(Paths.get(profileImagesDirectory + "profile_" + userId));
            imageBytes = FileUtils.decompressFile(imageBytes);
            storeImageVec.add(storeImageModel);
            apiReturnModel.setData(storeImageVec);
            apiReturnModel.setCount(storeImageVec.size());
            apiReturnModel.setMessage("File Downloaded Successfully !");
            apiReturnModel.setStatus("Success");
            return ResponseEntity.ok().contentType(org.springframework.http.MediaType.IMAGE_JPEG).body(imageBytes);
        } catch (Exception e) {
            apiReturnModel.setMessage("Something Went Wrong ! " + e.getMessage());
            apiReturnModel.setStatus("fail");
            return ResponseEntity.ok(apiReturnModel);
        }
    }

Uploading & Getting the Images:

Pasted image 20240401001426.png

Initially the Table is empty as we have not uploaded any files yet.

Using Arc to Upload Images :

Images will be posted on this URL : http://localhost:8085/profile/images/user
Image has successfully been uploaded.
Image's metadata is now visible in the SQL Database.
File is stored in the directory src/resources/static/profile/images.

Getting / Fetching an image ( using userId ):

http://localhost:8085/profile/images/user/1 : here 1 is the userId.

Full Code :

application.properties

spring.application.name=examtool
server.port=8085

# Database Connection
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/examportal
spring.datasource.username=root
spring.datasource.password=root

# Hibernate Configuration
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.generate-ddl=true
# generate ddl automatically created a table

# Path where an image uploaded will be stored :  
profile.images.directory=D:\\Repos (VS Code)\\Spring IIITL Class Lecs\\examtool\\src\\main\\resources\\static\\profile\\images\\

spring.http.multipart.max-file-size=10MB 
spring.http.multipart.max-request-size=11MB

StoreImageController.java :

/* ------------------------------------------------------ */

// With Compression and Decompression :

package com.tool.erp.storeimage.controller;

import com.tool.erp.file.model.FileModel;
import com.tool.erp.file.utils.FileUtils;
import com.tool.erp.setup.APIReturnModel;
import com.tool.erp.storeimage.model.StoreImageModel;
import com.tool.erp.storeimage.services.StoreImageService;
import com.tool.erp.users.service.UserService;
import jakarta.websocket.server.PathParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.Vector;

@RestController
@RequestMapping("/profile/images")
public class StoreImageController {
    @Autowired
    private StoreImageService storeImageService;

    @Autowired
    private UserService userService;

    private APIReturnModel apiReturnModel;
    private Vector<StoreImageModel> storeImageVec;

    @Value("${profile.images.directory}")
    private String profileImagesDirectory; // Path to the directory where the images will be stored

    /* ------------------Uploading an Image---------------- */
    @PostMapping("/user")
    ResponseEntity<?> uploadImage(@RequestParam("file") MultipartFile file, @RequestParam("userId") int userId) throws IOException {
        // ResponseEntity<?> uploadImage(@RequestParam("file") MultipartFile file, @PathParam("userId") int userId) throws IOException {
        apiReturnModel = new APIReturnModel();
        storeImageVec = new Vector<>();
        StoreImageModel storeImageModel = new StoreImageModel();
        storeImageModel.setOriginalName(file.getOriginalFilename());
        storeImageModel.setFileType(file.getContentType());
        storeImageModel.setUniqueName("profile_" + userId); // Generating a unique name for the file automatically based on the userId
        storeImageModel.setUser(this.userService.getUserById(userId));

        try {
            String filePath = profileImagesDirectory + "profile_" + userId;
            // Files.copy(file.getInputStream(), Paths.get(filePath), StandardCopyOption.REPLACE_EXISTING);
            byte[] fileData = FileUtils.compressFile(file.getBytes());
            Files.copy(new ByteArrayInputStream(fileData), Paths.get(filePath), StandardCopyOption.REPLACE_EXISTING);
            // Files.copy(file.getInputStream(), Paths.get(filePath), StandardCopyOption.REPLACE_EXISTING);

            StoreImageModel storeImageModel2 = this.storeImageService.uploadFile(storeImageModel);

            storeImageVec.add(storeImageModel2);
            apiReturnModel.setData(storeImageVec);
            apiReturnModel.setCount(storeImageVec.size());
            apiReturnModel.setMessage("File Uploaded Successfully !");
            apiReturnModel.setStatus("Success");
        } catch (Exception e) {
            apiReturnModel.setMessage("Something Went Wrong ! " + e.getMessage());
            // e.printStackTrace();
            apiReturnModel.setStatus("fail");
        }
        return ResponseEntity.ok(apiReturnModel);
    }

    /* -----------------Fetching the Image---------------- */
    @GetMapping("/user/{userId}")
    ResponseEntity<?> getImage(@PathVariable("userId") int userId) {
        apiReturnModel = new APIReturnModel();
        storeImageVec = new Vector<>();
        byte[] imageBytes;
        try {
            StoreImageModel storeImageModel = this.storeImageService.downloadFile(userId);
            imageBytes = Files.readAllBytes(Paths.get(profileImagesDirectory + "profile_" + userId));
            imageBytes = FileUtils.decompressFile(imageBytes);
            storeImageVec.add(storeImageModel);
            apiReturnModel.setData(storeImageVec);
            apiReturnModel.setCount(storeImageVec.size());
            apiReturnModel.setMessage("File Downloaded Successfully !");
            apiReturnModel.setStatus("Success");
            return ResponseEntity.ok().contentType(org.springframework.http.MediaType.IMAGE_JPEG).body(imageBytes);
        } catch (Exception e) {
            apiReturnModel.setMessage("Something Went Wrong ! " + e.getMessage());
            apiReturnModel.setStatus("fail");
            return ResponseEntity.ok(apiReturnModel);
        }
    }

    /* ------------------------------------------------------ */
    // "Delete" methods below are used for testing only and were not a part of the assignment
    @DeleteMapping("/user/{userId}")
    ResponseEntity<?> deleteImage(@PathVariable("userId") int userId) {
        apiReturnModel = new APIReturnModel();
        storeImageVec = new Vector<>();
        try {
            StoreImageModel storeImageModel = this.storeImageService.downloadFile(userId);
            Files.deleteIfExists(Paths.get(profileImagesDirectory + "profile_" + userId));
            this.storeImageService.deleteFile(userId);
            storeImageVec.add(storeImageModel);
            apiReturnModel.setData(storeImageVec);
            apiReturnModel.setCount(storeImageVec.size());
            apiReturnModel.setMessage("File Deleted Successfully !");
            apiReturnModel.setStatus("Success");
            return ResponseEntity.ok(apiReturnModel);
        } catch (Exception e) {
            apiReturnModel.setMessage("Something Went Wrong ! " + e.getMessage());
            apiReturnModel.setStatus("fail");
            return ResponseEntity.ok(apiReturnModel);
        }
    }

    // Delete all images : Only for testing purpose
    @DeleteMapping("/deleteAll")
    ResponseEntity<?> deleteAllImages() {
        apiReturnModel = new APIReturnModel();
        storeImageVec = new Vector<>();
        try {
            this.storeImageService.deleteAllFiles();
            apiReturnModel.setMessage("All Files Deleted Successfully !");
            apiReturnModel.setStatus("Success");
            return ResponseEntity.ok(apiReturnModel);
        } catch (Exception e) {
            apiReturnModel.setMessage("Something Went Wrong ! " + e.getMessage());
            apiReturnModel.setStatus("fail");
            return ResponseEntity.ok(apiReturnModel);
        }
    }
}

StoreImageModel.java :

package com.tool.erp.storeimage.model;

import com.tool.erp.users.model.UsersModel;
import jakarta.persistence.*;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "StoreImages")
public class StoreImageModel {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private int fileId;

    @Column(unique = true, updatable = false, nullable = false)
    private String uniqueName;

    private String originalName;

    private String fileType;

    @OneToOne
    @JoinColumn(name = "userId")
    private UsersModel user;
}

StoreImageRepo.java :

package com.tool.erp.storeimage.repositories;

import com.tool.erp.storeimage.model.StoreImageModel;
import org.springframework.data.jpa.repository.JpaRepository;

public interface StoreImageRepo extends JpaRepository<StoreImageModel, Integer> {
    StoreImageModel findByUserUserId(int userId);

    void deleteByFileId(int userId);
    void deleteAll();
}

StoreImageService.java :

package com.tool.erp.storeimage.services;

import com.tool.erp.storeimage.model.StoreImageModel;

public interface StoreImageService {
    StoreImageModel uploadFile(StoreImageModel storeImageModel);
    StoreImageModel downloadFile(int userId);
    void deleteFile(int userId);
    void deleteAllFiles();
}

StoreImageServiceImpl.java :

package com.tool.erp.storeimage.services;

import com.tool.erp.storeimage.model.StoreImageModel;
import com.tool.erp.storeimage.repositories.StoreImageRepo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class StoreImageServiceImpl implements StoreImageService{
    @Autowired
    private StoreImageRepo storeImageRepo;  // create a new instance of StoreImageRepo

    @Override
    public StoreImageModel uploadFile(StoreImageModel storeImageModel) {
        return this.storeImageRepo.save(storeImageModel);
    }

    @Override
    public StoreImageModel downloadFile(int userId) {
        return this.storeImageRepo.findByUserUserId(userId);
    }

    @Override
    public void deleteFile(int userId) {
        storeImageRepo.deleteByFileId(userId);
    }

    @Override
    public void deleteAllFiles() {
        storeImageRepo.deleteAll();
    }
}

Utility That is used for Compressing and Decompressing the images :

FileUtils.java

package com.tool.erp.file.utils;

import java.util.zip.Deflater;
import java.util.zip.Inflater;

import org.apache.tomcat.util.http.fileupload.ByteArrayOutputStream;

public class FileUtils {

    public static byte[] compressFile(byte[] data) {
        Deflater deflater = new Deflater();
        deflater.setLevel(Deflater.BEST_COMPRESSION);
        deflater.setInput(data);
        deflater.finish();
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(data.length);
        byte[] tmp = new byte[4 * 1024];

        while (!deflater.finished()) {
            int size = deflater.deflate(tmp);
            outputStream.write(tmp, 0, size);
        }
        try {
            outputStream.close();
        } catch (Exception ignored) {

        }
        return outputStream.toByteArray();
    }

    public static byte[] decompressFile(byte[] data) {
        Inflater inflater = new Inflater();
        inflater.setInput(data);
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(data.length);
        byte[] tmp = new byte[4 * 1024];
        try {
            while (!inflater.finished()) {
                int count = inflater.inflate(tmp);
                outputStream.write(tmp, 0, count);
            }
            outputStream.close();
        } catch (Exception ignored) {

        }
        return outputStream.toByteArray();
    }

}