Merge branch 'main' into describe-attachment-attributes

Author: mprins

src/main/java/org/tailormap/api/controller/AttachmentsController.java

@@ -9,7 +9,9 @@
 import java.io.IOException;
 import java.io.Serializable;
 import java.lang.invoke.MethodHandles;
+import java.nio.ByteBuffer;
 import java.sql.SQLException;
+import java.util.List;
 import java.util.Set;
 import java.util.UUID;
 import org.geotools.api.data.Query;
@@ -74,7 +76,7 @@ public AttachmentsController(EditUtil editUtil, FeatureSourceFactoryHelper featu
    */
   @PutMapping(
       path = {
-        "${tailormap-api.base-path}/{viewerKind}/{viewerName}/layer/{appLayerId}/feature/{featureId}/attachment"
+        "${tailormap-api.base-path}/{viewerKind}/{viewerName}/layer/{appLayerId}/feature/{featureId}/attachments"
       },
       consumes = MediaType.MULTIPART_FORM_DATA_VALUE,
       produces = MediaType.APPLICATION_JSON_VALUE)
@@ -92,10 +94,12 @@ public ResponseEntity<Serializable> addAttachment(
 
     TMFeatureType tmFeatureType = editUtil.getEditableFeatureType(application, appTreeLayerNode, service, layer);
 
+    checkFeatureExists(tmFeatureType, featureId);
+
     Set<@Valid AttachmentAttributeType> attachmentAttrSet =
         tmFeatureType.getSettings().getAttachmentAttributes();
     if (attachmentAttrSet == null || attachmentAttrSet.isEmpty()) {
-      throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Feature type does not support attachments");
+      throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Layer does not support attachments");
     }
 
     AttachmentAttributeType attachmentAttributeType = attachmentAttrSet.stream()
@@ -107,18 +111,14 @@ public ResponseEntity<Serializable> addAttachment(
         .findFirst()
         .orElseThrow(() -> new ResponseStatusException(
             HttpStatus.BAD_REQUEST,
-            "Feature type does not support attachments for attribute "
+            "Layer does not support attachments for attribute "
                 + attachment.getAttributeName()
                 + " with mime type "
                 + attachment.getMimeType()
                 + " and size "
                 + fileData.length));
     logger.debug("Using attachment attribute {}", attachmentAttributeType);
 
-    if (!checkFeatureExists(tmFeatureType, featureId)) {
-      throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Feature with id " + featureId + " does not exist");
-    }
-
     AttachmentMetadata response;
     try {
       response = AttachmentsHelper.insertAttachment(tmFeatureType, attachment, featureId, fileData);
@@ -129,32 +129,120 @@ public ResponseEntity<Serializable> addAttachment(
     return new ResponseEntity<>(response, HttpStatus.CREATED);
   }
 
-  @DeleteMapping(path = "${tailormap-api.base-path}/attachment/{attachmentId}")
-  public ResponseEntity<Serializable> deleteAttachment(@PathVariable UUID attachmentId) {
+  /**
+   * List attachments for a feature.
+   *
+   * @param appTreeLayerNode the application tree layer node
+   * @param service the geo service
+   * @param layer the geo service layer
+   * @param application the application
+   * @param featureId the feature id
+   * @return the response entity containing a list of attachment metadata
+   */
+  @GetMapping(
+      path = {
+        "${tailormap-api.base-path}/{viewerKind}/{viewerName}/layer/{appLayerId}/feature/{featureId}/attachments"
+      },
+      produces = MediaType.APPLICATION_JSON_VALUE)
+  @Transactional
+  public ResponseEntity<List<AttachmentMetadata>> listAttachments(
+      @ModelAttribute AppTreeLayerNode appTreeLayerNode,
+      @ModelAttribute GeoService service,
+      @ModelAttribute GeoServiceLayer layer,
+      @ModelAttribute Application application,
+      @PathVariable String featureId) {
+
+    TMFeatureType tmFeatureType = editUtil.getEditableFeatureType(application, appTreeLayerNode, service, layer);
+
+    checkFeatureTypeSupportsAttachments(tmFeatureType);
+    checkFeatureExists(tmFeatureType, featureId);
+
+    List<AttachmentMetadata> response;
+    try {
+      response = AttachmentsHelper.listAttachmentsForFeature(tmFeatureType, featureId);
+    } catch (IOException | SQLException e) {
+      throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage());
+    }
+
+    return new ResponseEntity<>(response, HttpStatus.OK);
+  }
+
+  @DeleteMapping(
+      path = "${tailormap-api.base-path}/{viewerKind}/{viewerName}/layer/{appLayerId}/attachment/{attachmentId}")
+  @Transactional
+  public ResponseEntity<Serializable> deleteAttachment(
+      @ModelAttribute AppTreeLayerNode appTreeLayerNode,
+      @ModelAttribute GeoService service,
+      @ModelAttribute GeoServiceLayer layer,
+      @ModelAttribute Application application,
+      @PathVariable UUID attachmentId) {
     editUtil.checkEditAuthorisation();
 
-    logger.debug("TODO: Deleting attachment with id {}", attachmentId);
-    throw new UnsupportedOperationException("Not implemented yet");
+    TMFeatureType tmFeatureType = editUtil.getEditableFeatureType(application, appTreeLayerNode, service, layer);
+
+    checkFeatureTypeSupportsAttachments(tmFeatureType);
+
+    try {
+      AttachmentsHelper.deleteAttachment(attachmentId, tmFeatureType);
+    } catch (IOException | SQLException e) {
+      throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage());
+    }
+
+    return new ResponseEntity<>(HttpStatus.NO_CONTENT);
   }
 
+  @Transactional
   @GetMapping(
-      path = "${tailormap-api.base-path}/attachment/{attachmentId}",
+      path = "${tailormap-api.base-path}/{viewerKind}/{viewerName}/layer/{appLayerId}/attachment/{attachmentId}",
       produces = {"application/octet-stream"})
-  // TODO determine return type: ResponseEntity<byte[]> or ResponseEntity<InputStreamResource>?
-  public ResponseEntity<byte[]> getAttachment(@PathVariable UUID attachmentId) {
-    logger.debug("TODO: Getting attachment with id {}", attachmentId);
+  public ResponseEntity<byte[]> getAttachment(
+      @ModelAttribute AppTreeLayerNode appTreeLayerNode,
+      @ModelAttribute GeoService service,
+      @ModelAttribute GeoServiceLayer layer,
+      @ModelAttribute Application application,
+      @PathVariable UUID attachmentId) {
 
-    throw new UnsupportedOperationException("Not implemented yet");
+    TMFeatureType tmFeatureType = editUtil.getEditableFeatureType(application, appTreeLayerNode, service, layer);
+
+    try {
+      final AttachmentsHelper.AttachmentWithBinary attachmentWithBinary =
+          AttachmentsHelper.getAttachment(tmFeatureType, attachmentId);
+
+      if (attachmentWithBinary == null) {
+        throw new ResponseStatusException(
+            HttpStatus.NOT_FOUND, "Attachment %s not found".formatted(attachmentId.toString()));
+      }
+
+      // the binary attachment() is a read-only ByteBuffer, so we cant use .array()
+      final ByteBuffer bb = attachmentWithBinary.attachment().asReadOnlyBuffer();
+      bb.rewind();
+      byte[] attachmentData = new byte[bb.remaining()];
+      bb.get(attachmentData);
+
+      return ResponseEntity.ok()
+          .header(
+              "Content-Disposition",
+              "inline; filename=\""
+                  + attachmentWithBinary.attachmentMetadata().getFileName() + "\"")
+          .contentType(MediaType.parseMediaType(
+              attachmentWithBinary.attachmentMetadata().getMimeType()))
+          .body(attachmentData);
+    } catch (SQLException | IOException e) {
+      throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage());
+    }
   }
 
-  private boolean checkFeatureExists(TMFeatureType tmFeatureType, String featureId) {
+  private void checkFeatureExists(TMFeatureType tmFeatureType, String featureId) throws ResponseStatusException {
     final Filter fidFilter = ff.id(ff.featureId(featureId));
     SimpleFeatureSource fs = null;
     try {
       fs = featureSourceFactoryHelper.openGeoToolsFeatureSource(tmFeatureType);
       Query query = new Query();
       query.setFilter(fidFilter);
-      return fs.getCount(query) > 0;
+      if (fs.getCount(query) < 1) {
+        throw new ResponseStatusException(
+            HttpStatus.NOT_FOUND, "Feature with id " + featureId + " does not exist");
+      }
     } catch (IOException e) {
       throw new ResponseStatusException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage());
     } finally {
@@ -163,4 +251,12 @@ private boolean checkFeatureExists(TMFeatureType tmFeatureType, String featureId
       }
     }
   }
+
+  private void checkFeatureTypeSupportsAttachments(TMFeatureType tmFeatureType) throws ResponseStatusException {
+    Set<@Valid AttachmentAttributeType> attachmentAttrSet =
+        tmFeatureType.getSettings().getAttachmentAttributes();
+    if (attachmentAttrSet == null || attachmentAttrSet.isEmpty()) {
+      throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Layer does not support attachments");
+    }
+  }
 }

src/main/java/org/tailormap/api/geotools/featuresources/AttachmentsHelper.java

@@ -18,6 +18,7 @@
 import java.text.MessageFormat;
 import java.time.OffsetDateTime;
 import java.time.ZoneId;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 import java.util.UUID;
@@ -244,7 +245,8 @@ private static String getCreateAttachmentsForFeatureTypeStatements(
       typeModifier = getValidModifier(fkColumnType, fkColumnSize);
     }
     logger.debug(
-        "Creating attachment table for feature type with primary key {} (native type: {}, meta type: {}, size: {} (modifier: {}))",
+        "Creating attachment table for feature type with primary key {} (native type: {}, meta type: {}, size:"
+            + " {} (modifier: {}))",
         pkDescriptor.getLocalName(),
         fkColumnType,
         pkDescriptor.getUserData().get("org.geotools.jdbc.nativeTypeName"),
@@ -388,21 +390,25 @@ public static AttachmentMetadata insertAttachment(
 """,
         featureType.getName());
 
-    byte[] attachmentIdBytes = asBytes(attachment.getAttachmentId());
-
     JDBCDataStore ds = null;
     try {
       ds = (JDBCDataStore) new JDBCFeatureSourceHelper().createDataStore(featureType.getFeatureSource());
+
+      Class<?> typeOfPK = ds.getSchema(featureType.getName())
+          .getDescriptor(featureType.getPrimaryKeyAttribute())
+          .getType()
+          .getBinding();
+
       try (Connection conn = ds.getDataSource().getConnection();
           PreparedStatement stmt = conn.prepareStatement(insertSql)) {
 
-        stmt.setString(1, featureId);
+        stmt.setObject(1, featureId, ds.getMapping(typeOfPK));
         if (featureType
             .getFeatureSource()
             .getJdbcConnection()
             .getDbtype()
             .equals(JDBCConnectionProperties.DbtypeEnum.ORACLE)) {
-          stmt.setBytes(2, attachmentIdBytes);
+          stmt.setBytes(2, asBytes(attachment.getAttachmentId()));
         } else {
           stmt.setObject(2, attachment.getAttachmentId());
         }
@@ -426,4 +432,152 @@ public static AttachmentMetadata insertAttachment(
       }
     }
   }
+
+  public static void deleteAttachment(UUID attachmentId, TMFeatureType featureType) throws IOException, SQLException {
+    String deleteSql = MessageFormat.format(
+        """
+DELETE FROM {0}_attachments WHERE attachment_id = ?
+""", featureType.getName());
+    JDBCDataStore ds = null;
+    try {
+      ds = (JDBCDataStore) new JDBCFeatureSourceHelper().createDataStore(featureType.getFeatureSource());
+      try (Connection conn = ds.getDataSource().getConnection();
+          PreparedStatement stmt = conn.prepareStatement(deleteSql)) {
+        if (featureType
+            .getFeatureSource()
+            .getJdbcConnection()
+            .getDbtype()
+            .equals(JDBCConnectionProperties.DbtypeEnum.ORACLE)) {
+          stmt.setBytes(1, asBytes(attachmentId));
+        } else {
+          stmt.setObject(1, attachmentId);
+        }
+
+        stmt.executeUpdate();
+      }
+    } finally {
+      if (ds != null) {
+        ds.dispose();
+      }
+    }
+  }
+
+  public static List<AttachmentMetadata> listAttachmentsForFeature(TMFeatureType featureType, String featureId)
+      throws IOException, SQLException {
+
+    String querySql = MessageFormat.format(
+        """
+SELECT
+{0}_pk,
+attachment_id,
+file_name,
+attribute_name,
+description,
+attachment_size,
+mime_type,
+created_at,
+created_by
+FROM {0}_attachments WHERE {0}_pk = ?
+""",
+        featureType.getName());
+
+    List<AttachmentMetadata> attachments = new ArrayList<>();
+    JDBCDataStore ds = null;
+    try {
+      ds = (JDBCDataStore) new JDBCFeatureSourceHelper().createDataStore(featureType.getFeatureSource());
+      try (Connection conn = ds.getDataSource().getConnection();
+          PreparedStatement stmt = conn.prepareStatement(querySql)) {
+
+        stmt.setString(1, featureId);
+
+        try (ResultSet rs = stmt.executeQuery()) {
+          while (rs.next()) {
+            AttachmentMetadata a = new AttachmentMetadata();
+            // attachment_id (handle UUID, RAW(16) as byte[] or string)
+            Object idObj = rs.getObject("attachment_id");
+            if (idObj instanceof UUID u) {
+              a.setAttachmentId(u);
+            } else if (idObj instanceof byte[] b) {
+              ByteBuffer bb = ByteBuffer.wrap(b);
+              a.setAttachmentId(new UUID(bb.getLong(), bb.getLong()));
+            } else {
+              String s = rs.getString("attachment_id");
+              if (s != null && !s.isEmpty()) {
+                a.setAttachmentId(UUID.fromString(s));
+              }
+            }
+            a.setFileName(rs.getString("file_name"));
+            a.setAttributeName(rs.getString("attribute_name"));
+            a.setDescription(rs.getString("description"));
+            long size = rs.getLong("attachment_size");
+            if (!rs.wasNull()) {
+              a.setAttachmentSize(size);
+            }
+            a.setMimeType(rs.getString("mime_type"));
+            java.sql.Timestamp ts = rs.getTimestamp("created_at");
+            if (ts != null) {
+              a.setCreatedAt(OffsetDateTime.ofInstant(ts.toInstant(), ZoneId.of("UTC")));
+            }
+            a.setCreatedBy(rs.getString("created_by"));
+            attachments.add(a);
+          }
+        }
+      }
+    } finally {
+      if (ds != null) {
+        ds.dispose();
+      }
+    }
+    return attachments;
+  }
+
+  public static AttachmentWithBinary getAttachment(TMFeatureType featureType, UUID attachmentId)
+      throws IOException, SQLException {
+
+    String querySql = MessageFormat.format(
+        "SELECT attachment, attachment_size, mime_type, file_name FROM {0}_attachments WHERE attachment_id = ?",
+        featureType.getName());
+    JDBCDataStore ds = null;
+    try {
+      byte[] attachment;
+      ds = (JDBCDataStore) new JDBCFeatureSourceHelper().createDataStore(featureType.getFeatureSource());
+      try (Connection conn = ds.getDataSource().getConnection();
+          PreparedStatement stmt = conn.prepareStatement(querySql)) {
+
+        if (featureType
+            .getFeatureSource()
+            .getJdbcConnection()
+            .getDbtype()
+            .equals(JDBCConnectionProperties.DbtypeEnum.ORACLE)) {
+          stmt.setBytes(1, asBytes(attachmentId));
+        } else {
+          stmt.setObject(1, attachmentId);
+        }
+
+        try (ResultSet rs = stmt.executeQuery()) {
+          if (rs.next()) {
+            attachment = rs.getBytes("attachment");
+            AttachmentMetadata a = new AttachmentMetadata();
+            long size = rs.getLong("attachment_size");
+            if (!rs.wasNull()) {
+              a.setAttachmentSize(size);
+            }
+            a.setMimeType(rs.getString("mime_type"));
+            a.setFileName(rs.getString("file_name"));
+            return new AttachmentWithBinary(
+                a, ByteBuffer.wrap(attachment).asReadOnlyBuffer());
+          } else {
+            return null;
+          }
+        }
+      }
+    } finally {
+      if (ds != null) {
+        ds.dispose();
+      }
+    }
+  }
+
+  public record AttachmentWithBinary(
+      @NotNull AttachmentMetadata attachmentMetadata, @NotNull ByteBuffer attachment) {}
 }