Cloudinary File Upload Integration

book-network-ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "book-network-ui",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "scripts": {
     "ng": "ng",
     "start": "ng serve",

book-network/pom.xml

@@ -10,7 +10,7 @@
 	</parent>
 	<groupId>com.ichaabane</groupId>
 	<artifactId>book-network</artifactId>
-	<version>1.0.0</version>
+	<version>1.1.0</version>
 	<name>book-network-api</name>
 	<description>Book-Social-Network</description>
 	<properties>
@@ -74,6 +74,22 @@
 			<artifactId>jjwt-jackson</artifactId>
 			<version>0.11.5</version>
 		</dependency>
+		<!-- Cloudinary for cloud storage -->
+		<dependency>
+			<groupId>com.cloudinary</groupId>
+			<artifactId>cloudinary-http44</artifactId>
+			<version>1.39.0</version>
+		</dependency>
+		<dependency>
+  			<groupId>org.apache.commons</groupId>
+  			<artifactId>commons-lang3</artifactId>
+  			<version>3.18.0</version>
+		</dependency>
+		<dependency>
+  			<groupId>org.apache.httpcomponents</groupId>
+  			<artifactId>httpclient</artifactId>
+  			<version>4.5.13</version>
+		</dependency>
 		<dependency>
 			<groupId>org.springdoc</groupId>
 			<artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>

book-network/src/main/java/com/ichaabane/book_network/application/dto/response/BookResponse.java

@@ -14,7 +14,7 @@ public class BookResponse {
     private String isbn;
     private String synopsis;
     private String owner;
-    private byte[] cover;
+    private String cover;
     private double rate;
     private boolean archived;
     private boolean shareable;

book-network/src/main/java/com/ichaabane/book_network/application/mapper/BookMapper.java

@@ -35,7 +35,7 @@ public BookResponse toBookResponse(Book book) {
                 .shareable(book.isShareable())
                 .rate(book.getRate())
                 .owner(book.getOwner().getFullName())
-                .cover(FileUtils.readFileFromLocation(book.getBookCover()))
+                .cover(book.getBookCover())
                 .build();
     }
 

book-network/src/main/java/com/ichaabane/book_network/application/service/BookService.java

@@ -6,12 +6,10 @@
 import com.ichaabane.book_network.application.dto.response.PageResponse;
 import com.ichaabane.book_network.application.mapper.BookMapper;
 import com.ichaabane.book_network.domain.exception.OperationNotPermittedException;
-import com.ichaabane.book_network.application.service.FileStorageService;
 import com.ichaabane.book_network.domain.model.Book;
 import com.ichaabane.book_network.domain.model.BookTransactionHistory;
 import com.ichaabane.book_network.domain.repository.BookRepository;
 import com.ichaabane.book_network.domain.repository.BookTransactionHistoryRepository;
-import com.ichaabane.book_network.application.service.NotificationService;
 import com.ichaabane.book_network.domain.model.BookReservation;
 import com.ichaabane.book_network.domain.repository.BookReservationRepository;
 import com.ichaabane.book_network.domain.model.User;
@@ -46,7 +44,7 @@ public class BookService {
     private final BookTransactionHistoryRepository transactionHistoryRepository;
     private final BookMapper bookMapper;
     private final BookTransactionHistoryRepository bookTransactionHistoryRepository;
-    private final FileStorageService fileStorageService;
+    private final CloudinaryService cloudinaryService;
     private final NotificationService notificationService;
     private final BookReservationRepository reservationRepository;
 
@@ -276,11 +274,25 @@ public void uploadCover(MultipartFile file, Authentication connectedUser, Intege
         if (file == null || file.isEmpty()) return;
 
         Book book = bookRepository.findById(bookId)
-            .orElseThrow(() -> new EntityNotFoundException(NO_BOOK_FOUND_PREFIX + bookId));
+                .orElseThrow(() -> new EntityNotFoundException(NO_BOOK_FOUND_PREFIX + bookId));
         User user = ((User) connectedUser.getPrincipal());
-        var bookCover = fileStorageService.saveFile(file, user.getId());
-        log.info(bookCover);
-        book.setBookCover(bookCover);
+
+        // Upload new cover to Cloudinary first
+        String coverUrl = cloudinaryService.uploadUserFile(file, user.getId());
+
+        // Verify upload was successful
+        if (coverUrl == null || coverUrl.isEmpty()) {
+            throw new OperationNotPermittedException("Failed to upload book cover");
+        }
+
+        log.info("New cover uploaded: {}", coverUrl);
+
+        // Only delete old cover after successful upload
+        if (book.getBookCover() != null) {
+            cloudinaryService.deleteFile(book.getBookCover());
+        }
+
+        book.setBookCover(coverUrl);
         bookRepository.save(book);
     }
 

book-network/src/main/java/com/ichaabane/book_network/application/service/CloudinaryService.java

@@ -0,0 +1,152 @@
+package com.ichaabane.book_network.application.service;
+
+import com.cloudinary.Cloudinary;
+import com.cloudinary.utils.ObjectUtils;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.UUID;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class CloudinaryService {
+
+    private final Cloudinary cloudinary;
+
+    /**
+     * Upload file to Cloudinary
+     *
+     * @param file The file to upload
+     * @param folder The folder name in Cloudinary (e.g., "book-covers")
+     * @return The secure URL of the uploaded file
+     */
+    public String uploadFile(MultipartFile file, String folder) {
+        try {
+            // Generate unique public ID
+            String publicId = generatePublicId();
+
+            // Upload to Cloudinary
+            Map<String, Object> uploadResult = cloudinary.uploader().upload(
+                    file.getBytes(),
+                    ObjectUtils.asMap(
+                            "folder", folder,
+                            "public_id", publicId,
+                            "resource_type", "auto",
+                            "transformation", new com.cloudinary.Transformation()
+                                    .width(500)
+                                    .height(700)
+                                    .crop("limit")
+                                    .quality("auto:good")
+                                    .fetchFormat("auto")
+                    )
+            );
+
+            String secureUrl = (String) uploadResult.get("secure_url");
+            log.info("File uploaded successfully to Cloudinary: {}", secureUrl);
+            return secureUrl;
+
+        } catch (IOException e) {
+            log.error("Failed to upload file to Cloudinary: {}", e.getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * Upload file for a specific user
+     *
+     * @param file The file to upload
+     * @param userId The user ID
+     * @return The secure URL of the uploaded file
+     */
+    public String uploadUserFile(
+            MultipartFile file,
+            Integer userId) {
+        String folder = "book-network/users/" + userId;
+        return uploadFile(file, folder);
+    }
+
+    /**
+     * Delete file from Cloudinary
+     *
+     * @param imageUrl The full URL of the image to delete
+     */
+    public void deleteFile(String imageUrl) {
+        if (imageUrl == null || imageUrl.isEmpty()) {
+            return;
+        }
+
+        try {
+            // Extract public ID from URL
+            String publicId = extractPublicId(imageUrl);
+            if (publicId != null) {
+                cloudinary.uploader().destroy(publicId, ObjectUtils.emptyMap());
+                log.info("File deleted from Cloudinary: {}", publicId);
+            }
+        } catch (IOException e) {
+            log.error("Failed to delete file from Cloudinary: {}", e.getMessage());
+        }
+    }
+
+    /**
+     * Generate unique public ID for file
+     * Note: No extension is appended as Cloudinary handles file types automatically with "resource_type":"auto"
+     */
+    private String generatePublicId() {
+        return UUID.randomUUID().toString() + "-" + System.currentTimeMillis();
+    }
+
+    /**
+     * Extract public ID from Cloudinary URL
+     * Example URL: https://res.cloudinary.com/demo/image/upload/v1234567890/folder/file.jpg
+     * Public ID: folder/file
+     */
+    private String extractPublicId(String imageUrl) {
+        try {
+            // Split by "upload/"
+            String[] parts = imageUrl.split("/upload/");
+            if (parts.length < 2) {
+                return null;
+            }
+
+            // Get the part after "upload/"
+            String afterUpload = parts[1];
+
+            // Find version token pattern: v followed by digits (e.g., v1234567890)
+            java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("v\\d+");
+            java.util.regex.Matcher matcher = pattern.matcher(afterUpload);
+
+            if (matcher.find()) {
+                // Extract everything after the version token
+                int versionEnd = matcher.end();
+                if (versionEnd < afterUpload.length()) {
+                    afterUpload = afterUpload.substring(versionEnd);
+
+                    // Strip leading "/"
+                    if (afterUpload.startsWith("/")) {
+                        afterUpload = afterUpload.substring(1);
+                    }
+                } else {
+                    return null; // No content after version token
+                }
+            } else {
+                return null; // No version token found
+            }
+
+            // Remove file extension
+            int lastDot = afterUpload.lastIndexOf(".");
+            if (lastDot > 0) {
+                afterUpload = afterUpload.substring(0, lastDot);
+            }
+
+            return afterUpload;
+        } catch (Exception e) {
+            log.error("Failed to extract public ID from URL: {}", imageUrl);
+            return null;
+        }
+    }
+}

book-network/src/main/java/com/ichaabane/book_network/infrastructure/config/CloudinaryConfig.java

@@ -0,0 +1,30 @@
+package com.ichaabane.book_network.infrastructure.config;
+
+import com.cloudinary.Cloudinary;
+import com.cloudinary.utils.ObjectUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class CloudinaryConfig {
+
+    @Value("${cloudinary.cloud-name}")
+    private String cloudName;
+
+    @Value("${cloudinary.api-key}")
+    private String apiKey;
+
+    @Value("${cloudinary.api-secret}")
+    private String apiSecret;
+
+    @Bean
+    public Cloudinary cloudinary() {
+        return new Cloudinary(ObjectUtils.asMap(
+                "cloud_name", cloudName,
+                "api_key", apiKey,
+                "api_secret", apiSecret,
+                "secure", true
+        ));
+    }
+}

book-network/src/main/java/com/ichaabane/book_network/presentation/handler/GlobalExceptionHandler.java

@@ -3,6 +3,7 @@
 
 import com.ichaabane.book_network.domain.exception.*;
 import jakarta.mail.MessagingException;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.authentication.BadCredentialsException;
 import org.springframework.security.authentication.DisabledException;
@@ -18,6 +19,7 @@
 import static com.ichaabane.book_network.presentation.handler.BusinessErrorCodes.ACCOUNT_LOCKED;
 import static org.springframework.http.HttpStatus.*;
 
+@Slf4j
 @RestControllerAdvice
 public class GlobalExceptionHandler {
 
@@ -115,7 +117,8 @@ public ResponseEntity<ExceptionResponse> handleMethodArgumentNotValidException(M
 
     @ExceptionHandler(Exception.class)
     public ResponseEntity<ExceptionResponse> handleException(Exception exp) {
-        exp.printStackTrace();
+        // Use proper logging instead of printStackTrace for production
+        log.error("Unexpected error occurred", exp);
         return ResponseEntity
                 .status(INTERNAL_SERVER_ERROR)
                 .body(