Feat/new upload image

pom.xml

@@ -114,6 +114,11 @@
       <artifactId>firebase-admin</artifactId>
       <version>9.5.0</version>
     </dependency>
+    <dependency>
+      <groupId>com.google.cloud</groupId>
+      <artifactId>google-cloud-storage</artifactId>
+      <version>2.55.0</version>
+    </dependency>
   </dependencies>
 
   <build>

src/main/java/com/markguiang/backend/event/domain/adapters/http/EventController.java

@@ -95,7 +95,7 @@ public void updateDayDetails(
 
   @PreAuthorize("hasAuthority(T(com.markguiang.backend.role.domain.Role.Authority).WRITE.name())")
   @PutMapping("/image-url/{eventId}")
-  public void updateImageUrl(@PathVariable UUID eventId, URI imageUrl) throws IOException {
+  public void updateImageUrl(@PathVariable UUID eventId, @RequestParam("path") URI imageUrl) throws IOException {
     eventService.updateEventImage(eventId, imageUrl);
   }
 }

src/main/java/com/markguiang/backend/event/domain/adapters/jdbi/mappers/EventReducer.java

@@ -18,8 +18,16 @@ public class EventReducer implements LinkedHashMapRowReducer<UUID, Event> {
   @Override
   public void accumulate(Map<UUID, Event> map, RowView rowView) {
     UUID eventId = rowView.getColumn("event_id", UUID.class);
+    String statusStr = rowView.getColumn("status", String.class);
+    EventStatus status;
 
-    Event event =
+    if (statusStr != null) {
+        status = EventStatus.valueOf(statusStr);
+    } else {
+        status = null;
+    }
+
+      Event event =
         map.computeIfAbsent(
             eventId,
             id ->
@@ -30,7 +38,7 @@ public void accumulate(Map<UUID, Event> map, RowView rowView) {
                     rowView.getColumn("description", String.class),
                     rowView.getColumn("location", String.class),
                     rowView.getColumn("img_url", URI.class),
-                    EventStatus.valueOf(rowView.getColumn("status", String.class)),
+                    status,
                     new ArrayList<>()));
 
     UUID dayId = rowView.getColumn("day_id", UUID.class);

src/main/java/com/markguiang/backend/event/domain/models/Agenda.java

@@ -2,7 +2,7 @@
 
 import com.markguiang.backend.base.exceptions.InvalidDateRangeException;
 import com.markguiang.backend.base.model.ValueObject;
-import com.markguiang.backend.event.utils.DateUtils;
+import com.markguiang.backend.event.utils.Utils;
 import java.time.OffsetDateTime;
 import java.util.ArrayList;
 import java.util.Comparator;
@@ -32,8 +32,8 @@ public static boolean hasOverlappingTimes(List<Agenda> agendaList) {
   public static boolean allOnDate(List<Agenda> agendaList, OffsetDateTime date) {
     Objects.requireNonNull(date);
     for (Agenda agenda : agendaList) {
-      if (!DateUtils.onSameDate(agenda.getStartDate(), date)
-          || !DateUtils.onSameDate(agenda.getEndDate(), date)) {
+      if (!Utils.onSameDate(agenda.getStartDate(), date)
+          || !Utils.onSameDate(agenda.getEndDate(), date)) {
         return false;
       }
     }

src/main/java/com/markguiang/backend/event/domain/models/Event.java

@@ -4,7 +4,7 @@
 import com.markguiang.backend.base.model.IdentifiableDomainObject;
 import com.markguiang.backend.event.exceptions.DayNotFoundException;
 import com.markguiang.backend.event.exceptions.DaysOnSameDateException;
-import com.markguiang.backend.event.utils.DateUtils;
+import com.markguiang.backend.event.utils.Utils;
 import java.net.URI;
 import java.time.OffsetDateTime;
 import java.util.ArrayList;
@@ -155,7 +155,7 @@ public List<Day> getDays() {
 
   private Day getDayWithDate(OffsetDateTime date) {
     for (Day day : days) {
-      if (DateUtils.onSameDate(day.getDate(), date)) {
+      if (Utils.onSameDate(day.getDate(), date)) {
         return day;
       }
     }

src/main/java/com/markguiang/backend/event/domain/ports/EventService.java

@@ -21,7 +21,8 @@ public EventService(EventRepository er) {
   }
 
   public Event getEventOrThrow(UUID eventID) {
-    return er.findByID(eventID).orElseThrow(() -> new EventDoesNotExistException(eventID));
+    return er.findByID(eventID).orElseThrow(() ->
+            new EventDoesNotExistException(eventID));
   }
 
   public Event getEvent(UUID eventID) {

src/main/java/com/markguiang/backend/event/utils/Utils.java

@@ -0,0 +1,18 @@
+package com.markguiang.backend.event.utils;
+
+import java.time.OffsetDateTime;
+
+public class Utils {
+  public static boolean onSameDate(OffsetDateTime a, OffsetDateTime b) {
+    return a.toLocalDate().equals(b.toLocalDate());
+  }
+
+  public static String concatenateStr(String... s) {
+    StringBuilder sb = new StringBuilder();
+    for (String string : s) {
+      sb.append(string);
+    }
+
+    return sb.toString();
+  }
+}

src/main/java/com/markguiang/backend/infrastructure/storage/GCPObjectStore.java

@@ -0,0 +1,111 @@
+package com.markguiang.backend.infrastructure.storage;
+
+import com.google.auth.oauth2.ServiceAccountCredentials;
+import com.google.cloud.storage.*;
+import com.markguiang.backend.infrastructure.storage.base.ObjectStore;
+import com.markguiang.backend.infrastructure.storage.base.StorageDetails;
+import com.markguiang.backend.infrastructure.storage.base.StoreProperties;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Primary;
+import org.springframework.stereotype.Component;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+import static com.markguiang.backend.event.utils.Utils.concatenateStr;
+
+@Component
+@Primary
+public class GCPObjectStore implements ObjectStore {
+    @Value("${GCP_PROJECTID}")
+    private String projectId;
+
+    @Value("${GCP_BUCKET_PUBLIC}")
+    private String publicBucket;
+
+    @Value("${GCP_BUCKET_PRIVATE}")
+    private String privateBucket;
+
+    @Value("${GOOGLE_CLOUD_STORAGE_JSON}")
+    private String sa;
+
+    private static final String SUFFIX = "/";
+    private static final String BUCKET_PATH_EVENT = "event/";
+
+    private static final String BUCKET_PATH_USER = "users/";
+
+    private StoreProperties initProperties(Boolean isPublic) {
+        return StoreProperties
+                .builder()
+                .projectId(projectId)
+                .bucket(isPublic ? publicBucket : privateBucket)
+                .sa(sa)
+                .build();
+    }
+
+    public URL generatePresignedUrlForDownload(String key) throws IOException {
+        return generateSignedUrl(key);
+    }
+
+    public StorageDetails generatePresignedUrlForUpload(UUID id, String fileType, String fileExtension, boolean isPublic) throws IOException {
+        String filename = RandomStringUtils.randomAlphabetic(20) + "." + fileExtension;
+
+        String filePath = concatenateStr(BUCKET_PATH_EVENT, id.toString(), SUFFIX, filename);
+
+        URL signedUrl = generateV4PutObjectSignedUrl(initProperties(isPublic), filePath, fileType);
+
+        return new StorageDetails(filePath, signedUrl);
+    }
+
+
+    private URL generateV4PutObjectSignedUrl(StoreProperties properties, String path, String contentType) throws IOException {
+
+        Storage storage = StorageOptions.newBuilder().setProjectId(properties.getProjectId()).build().getService();
+
+        BlobInfo blobInfo = BlobInfo.newBuilder(BlobId.of(properties.getBucket(), path)).build();
+
+        Map<String, String> extensionHeaders = new HashMap<>();
+        extensionHeaders.put("Content-Type", contentType);
+
+        return storage.signUrl(
+                blobInfo,
+                15,
+                TimeUnit.MINUTES,
+                Storage.SignUrlOption.httpMethod(HttpMethod.PUT),
+                Storage.SignUrlOption.withExtHeaders(extensionHeaders),
+                Storage.SignUrlOption.withV4Signature(),
+                Storage.SignUrlOption.signWith(
+                        ServiceAccountCredentials
+                                .fromStream(new ByteArrayInputStream(properties.getSa().getBytes(StandardCharsets.UTF_8)))
+                )
+        );
+    }
+
+    public URL generateSignedUrl(String objectPath) throws IOException {
+        Storage storage = StorageOptions.newBuilder()
+                .setProjectId(projectId)
+                .setCredentials(
+                        ServiceAccountCredentials.fromStream(
+                                new ByteArrayInputStream(sa.getBytes(StandardCharsets.UTF_8)) // since sa is a JSON string
+                        )
+                )
+                .build()
+                .getService();
+
+        BlobInfo blobInfo = BlobInfo.newBuilder(privateBucket, objectPath).build();
+
+        return storage.signUrl(
+                blobInfo,
+                15,
+                TimeUnit.MINUTES,
+                Storage.SignUrlOption.withV4Signature()
+        );
+    }
+}

src/main/java/com/markguiang/backend/infrastructure/storage/LocalObjectStore.java

@@ -1,15 +1,19 @@
 package com.markguiang.backend.infrastructure.storage;
 
 import com.markguiang.backend.infrastructure.storage.base.DirectObjectStore;
+import com.markguiang.backend.infrastructure.storage.base.StorageDetails;
 import org.springframework.stereotype.Component;
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.MalformedURLException;
 import java.net.URI;
+import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardCopyOption;
+import java.util.UUID;
 
 @Component
 public class LocalObjectStore implements DirectObjectStore {
@@ -32,11 +36,14 @@ public InputStream fetch(URI presignedUrl) throws IOException {
     return Files.newInputStream(source);
   }
 
-  public URI generatePresignedUrlForDownload(String key) {
-    return URI.create(key);
+  public URL generatePresignedUrlForDownload(String key) throws MalformedURLException {
+      return URI.create(key).toURL();
   }
 
-  public URI generatePresignedUrlForUpload(String key) {
-    return URI.create(key);
+  public StorageDetails generatePresignedUrlForUpload(UUID id, String fileType, String fileExtension, boolean isPublic) throws IOException {
+      String key = "/event/" + id + "/upload." + fileExtension;
+      URL presignedUrl = URI.create(key).toURL();
+
+      return new StorageDetails(key, presignedUrl);
   }
 }

src/main/java/com/markguiang/backend/infrastructure/storage/StorageConfig.java

@@ -8,7 +8,7 @@
 public class StorageConfig {
 
   @Bean
-  public StorageService storageService(ObjectStore objectStore) {
-    return new StorageService(objectStore);
+  public StorageService storageService(ObjectStore objectStore, GCPObjectStore gcpObjectStore) {
+    return new StorageService(objectStore, gcpObjectStore);
   }
 }

src/main/java/com/markguiang/backend/infrastructure/storage/StorageService.java

@@ -2,18 +2,25 @@
 
 import com.markguiang.backend.infrastructure.storage.base.DirectObjectStore;
 import com.markguiang.backend.infrastructure.storage.base.ObjectStore;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URI;
+import java.net.URL;
+import java.util.UUID;
+
+import com.markguiang.backend.infrastructure.storage.base.StorageDetails;
 import org.springframework.stereotype.Service;
 import org.springframework.web.multipart.MultipartFile;
 
 @Service
 public class StorageService {
   private final ObjectStore os;
+  private final GCPObjectStore gcpObjectStore;
 
-  public StorageService(ObjectStore os) {
+  public StorageService(ObjectStore os, GCPObjectStore gcpObjectStore) {
     this.os = os;
+    this.gcpObjectStore = gcpObjectStore;
   }
 
   public URI store(InputStream is, URI presignedUrl) throws IOException {
@@ -34,11 +41,12 @@ public InputStream fetch(URI presignedUrl) throws IOException {
     throw new UnsupportedOperationException("direct-storage-not-supported-by-this-implementation");
   }
 
-  public URI generatePresignedUrlForUpload(String key) {
-    return os.generatePresignedUrlForUpload(key);
+  public StorageDetails generatePresignedUrlForUpload(UUID id, String fileType, String fileExtension, Boolean isPublic) throws IOException {
+    return gcpObjectStore.generatePresignedUrlForUpload(id, fileType, fileExtension, isPublic);
   }
 
-  public URI generatePresignedUrlForDownload(String key) {
-    return os.generatePresignedUrlForDownload(key);
+  public URL generatePresignedUrlForDownload(String key) throws IOException {
+    return gcpObjectStore.generatePresignedUrlForDownload(key);
   }
+
 }

src/main/java/com/markguiang/backend/infrastructure/storage/base/ObjectStore.java

@@ -1,9 +1,11 @@
 package com.markguiang.backend.infrastructure.storage.base;
 
-import java.net.URI;
+import java.io.IOException;
+import java.net.URL;
+import java.util.UUID;
 
 public interface ObjectStore {
-  public URI generatePresignedUrlForDownload(String key);
+  public URL generatePresignedUrlForDownload(String key) throws IOException;
 
-  public URI generatePresignedUrlForUpload(String key);
+  public StorageDetails generatePresignedUrlForUpload(UUID id, String fileType, String fileExtension, boolean isPublic) throws IOException;
 }

src/main/java/com/markguiang/backend/infrastructure/storage/base/StorageDetails.java

@@ -0,0 +1,6 @@
+package com.markguiang.backend.infrastructure.storage.base;
+
+import java.net.URL;
+
+public record StorageDetails(String filePath, URL url) {
+}