public String saveProfilePicture(String userId, Path path) {
    UploadRequest request = UploadRequest.fromPath(path, userId); // (1)
    UploadResponse<?> response = objectStorage.upload(request); // (2)
    return response.getKey(); // (3)
}

open fun saveProfilePicture(userId: String, path: Path): String? {
    val request = UploadRequest.fromPath(path, userId) // (1)
    val response = objectStorage.upload(request) // (2)
    return response.key // (3)
}

String saveProfilePicture(String userId, Path path) {
    UploadRequest request = UploadRequest.fromPath(path, userId) // (1)
    UploadResponse response = objectStorage.upload(request) // (2)
    response.key // (3)
}

UploadResponse<PutObjectResponse> response = objectStorage.upload(objectStorageUpload, builder -> {
    builder.acl(ObjectCannedACL.PUBLIC_READ);
});

val response = objectStorage.upload(objectStorageUpload) { builder: PutObjectRequest.Builder ->
    builder.acl(ObjectCannedACL.PUBLIC_READ)
}

UploadResponse<PutObjectResponse> response = objectStorage.upload(objectStorageUpload, { builder ->
    builder.acl(ObjectCannedACL.PUBLIC_READ)
})

@Post(uri = "/stream", consumes = MediaType.MULTIPART_FORM_DATA, produces = MediaType.TEXT_PLAIN)
public HttpResponse<String> streamingUpload(StreamingFileUpload fileUpload) {
    UploadRequest objectStorageUpload = UploadRequest.fromStreamingFileUpload(fileUpload, "uploads/" + fileUpload.getFilename());
    UploadResponse<PutObjectResponse> response = objectStorage.upload(objectStorageUpload);
    return HttpResponse
        .created(response.getKey())
        .header("ETag", response.getNativeResponse().eTag());
}

@Post(uri = "/stream", consumes = [MediaType.MULTIPART_FORM_DATA], produces = [MediaType.TEXT_PLAIN])
open fun streamingUpload(fileUpload: StreamingFileUpload): HttpResponse<String>? {
    val objectStorageUpload = UploadRequest.fromStreamingFileUpload(fileUpload, "uploads/${fileUpload.filename}")
    val response: io.micronaut.objectstorage.response.UploadResponse<PutObjectResponse> = objectStorage.upload(objectStorageUpload)
    return HttpResponse
        .created(response.key)
        .header("ETag", response.nativeResponse.eTag())
}

@Post(uri = "/stream", consumes = MediaType.MULTIPART_FORM_DATA, produces = MediaType.TEXT_PLAIN)
HttpResponse<String> streamingUpload(StreamingFileUpload fileUpload) {
    UploadRequest objectStorageUpload = UploadRequest.fromStreamingFileUpload(fileUpload, "uploads/${fileUpload.filename}")
    UploadResponse<PutObjectResponse> response = objectStorage.upload(objectStorageUpload)
    return HttpResponse
            .created(response.key)
            .header("ETag", response.getNativeResponse().eTag())
}

public String saveProfilePicture(String userId, InputStream inputStream, long contentLength) {
    UploadRequest request = UploadRequest.fromInputStream(
        inputStream,
        userId + "/profile.jpg",
        "image/jpeg",
        contentLength // (1)
    );
    request.setMetadata(Map.of("source", "validated-upload")); // (2)
    return objectStorage.upload(request).getKey();
}

open fun saveProfilePicture(userId: String, inputStream: InputStream, contentLength: Long): String? {
    val request = UploadRequest.fromInputStream(
        inputStream,
        "$userId/profile.jpg",
        "image/jpeg",
        contentLength // (1)
    )
    request.metadata = mapOf("source" to "validated-upload") // (2)
    return objectStorage.upload(request).key
}

String saveProfilePicture(String userId, InputStream inputStream, long contentLength) {
    UploadRequest request = UploadRequest.fromInputStream(
        inputStream,
        "${userId}/profile.jpg",
        "image/jpeg",
        contentLength // (1)
    )
    request.metadata = [source: "validated-upload"] // (2)
    objectStorage.upload(request).key
}

public Optional<Path> retrieveProfilePicture(String userId, String fileName) {
    Path destination = null;
    try {
        String key = userId + "/" + fileName;
        Optional<InputStream> stream = objectStorage.retrieve(key) // (1)
            .map(ObjectStorageEntry::getInputStream);
        if (stream.isPresent()) {
            destination = File.createTempFile(userId, "temp").toPath();
            Files.copy(stream.get(), destination, StandardCopyOption.REPLACE_EXISTING);
            return Optional.of(destination);
        } else {
            return Optional.empty();
        }
    } catch (IOException e) {
        LOG.error("Error while trying to save profile picture to the local file [{}]: {}", destination, e.getMessage());
        return Optional.empty();
    }
}

open fun retrieveProfilePicture(userId: String, fileName: String): Path? {
    val key = "$userId/$fileName"
    val stream = objectStorage.retrieve<ObjectStorageEntry<*>>(key) // (1)
        .map { obj: ObjectStorageEntry<*> -> obj.inputStream }

    return if (stream.isPresent) {
        val destination = File.createTempFile(userId, "temp").toPath()
        Files.copy(stream.get(), destination, StandardCopyOption.REPLACE_EXISTING)
        destination
    } else {
        null
    }
}

Optional<Path> retrieveProfilePicture(String userId, String fileName) {
    String key = "${userId}/${fileName}"
    Optional<InputStream> stream = objectStorage.retrieve(key) // (1)
            .map(ObjectStorageEntry::getInputStream)
    if (stream.isPresent()) {
        Path destination = File.createTempFile(userId, "temp").toPath()
        Files.copy(stream.get(), destination, StandardCopyOption.REPLACE_EXISTING)
        return Optional.of(destination)
    } else {
        return Optional.empty()
    }
}

public void deleteProfilePicture(String userId, String fileName) {
    String key = userId + "/" + fileName;
    objectStorage.delete(key); // (1)
}

open fun deleteProfilePicture(userId: String, fileName: String) {
    val key = "$userId/$fileName"
    objectStorage.delete(key) // (1)
}

void deleteProfilePicture(String userId, String fileName) {
    String key = "${userId}/${fileName}"
    objectStorage.delete(key) // (1)
}

@Post(uri = "/signed", consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON)
public HttpResponse<PresignedUploadResponse> create(@Body CreateUploadCommand command) {
    CreatePresignedUploadRequest request =
        new CreatePresignedUploadRequest("profiles/" + command.userId() + ".png", Duration.ofMinutes(5)); // (1)
    request.setContentType(MediaType.IMAGE_PNG);
    request.setMetadata(Map.of("owner", command.userId()));

    PresignedUpload signedUpload = objectStorage.createPresignedUpload(request)
        .orElseThrow(() -> new IllegalStateException("This provider does not support pre-signed uploads"));

    return HttpResponse.ok(new PresignedUploadResponse( // (2)
        signedUpload.getUri().toString(),
        signedUpload.getMethod(),
        signedUpload.getHeaders(),
        signedUpload.getExpiration()
    ));
}

@Post(uri = "/signed", consumes = [MediaType.APPLICATION_JSON], produces = [MediaType.APPLICATION_JSON])
open fun create(@Body command: CreateUploadCommand): HttpResponse<PresignedUploadResponse> {
    val request = CreatePresignedUploadRequest("profiles/${command.userId}.png", Duration.ofMinutes(5)) // (1)
    request.setContentType(MediaType.IMAGE_PNG)
    request.setMetadata(mapOf("owner" to command.userId))

    val signedUpload = objectStorage.createPresignedUpload(request)
        .orElseThrow { IllegalStateException("This provider does not support pre-signed uploads") }

    return HttpResponse.ok(
        PresignedUploadResponse( // (2)
            signedUpload.uri.toString(),
            signedUpload.method,
            signedUpload.headers,
            signedUpload.expiration
        )
    )
}

@Post(uri = '/signed', consumes = MediaType.APPLICATION_JSON, produces = MediaType.APPLICATION_JSON)
HttpResponse<PresignedUploadResponse> create(@Body CreateUploadCommand command) {
    CreatePresignedUploadRequest request =
        new CreatePresignedUploadRequest("profiles/${command.userId}.png", Duration.ofMinutes(5)) // (1)
    request.contentType = MediaType.IMAGE_PNG
    request.metadata = [owner: command.userId]

    PresignedUpload signedUpload = objectStorage.createPresignedUpload(request)
        .orElseThrow(() -> new IllegalStateException('This provider does not support pre-signed uploads'))

    HttpResponse.ok(new PresignedUploadResponse( // (2)
        signedUpload.uri.toString(),
        signedUpload.method,
        signedUpload.headers,
        signedUpload.expiration
    ))
}

public void listProfilePicturesByPage(String userId) {
    String prefix = userId + "/"; // raw prefix filtering
    String continuation = null;
    do {
        ListObjectsRequest request = new ListObjectsRequest(2, prefix, continuation); // (1)
        ListObjectsResponse response = objectStorage.listObjects(request);

        // Process the keys in this page
        response.getKeys().forEach(key -> System.out.println("Found: " + key)); // (2)

        // Replay the continuation token returned by the provider for the next page
        continuation = response.getContinuationToken().orElse(null); // (3)
    } while (continuation != null);
}

open fun listProfilePicturesByPage(userId: String) {
    val prefix = "$userId/" // raw prefix filtering
    var continuation: String? = null
    do {
        val request = ListObjectsRequest(2, prefix, continuation) // (1)
        val response: ListObjectsResponse = objectStorage.listObjects(request)

        // Process the keys in this page
        response.keys.forEach { key -> println("Found: $key") } // (2)

        // Replay the continuation token returned by the provider for the next page
        continuation = response.continuationToken.orElse(null) // (3)
    } while (continuation != null)
}

void listProfilePicturesByPage(String userId) {
    String prefix = userId + "/" // raw prefix filtering
    String continuation = null
    do {
        ListObjectsRequest request = new ListObjectsRequest(2, prefix, continuation) // (1)
        ListObjectsResponse response = objectStorage.listObjects(request)

        // Process the keys in this page
        response.keys.forEach { key -> println("Found: $key") } // (2)

        // Replay the continuation token returned by the provider for the next page
        continuation = response.continuationToken.orElse(null) // (3)
    } while (continuation != null)
}

public String uploadVideo(String key, byte[] nonFinalChunk, byte[] finalChunk) {
    var createResponse = multipartObjectStorage.createMultipartUpload(
        new CreateMultipartUploadRequest(key, "video/mp4")
    );
    var upload = createResponse.getUpload();

    try {
        var firstPart = multipartObjectStorage.uploadPart(
            new UploadPartRequest(upload, 1, UploadRequest.fromBytes(nonFinalChunk, upload.getKey()))
        );
        var secondPart = multipartObjectStorage.uploadPart(
            new UploadPartRequest(upload, 2, UploadRequest.fromBytes(finalChunk, upload.getKey()))
        );

        multipartObjectStorage.completeMultipartUpload(
            new CompleteMultipartUploadRequest(upload, List.of(firstPart.getPart(), secondPart.getPart()))
        );
        return upload.getKey();
    } catch (RuntimeException e) {
        multipartObjectStorage.abortMultipartUpload(new AbortMultipartUploadRequest(upload));
        throw e;
    }
}

open fun uploadVideo(key: String, nonFinalChunk: ByteArray, finalChunk: ByteArray): String {
    val createResponse = multipartObjectStorage.createMultipartUpload(
        CreateMultipartUploadRequest(key, "video/mp4")
    )
    val upload = createResponse.upload

    try {
        val firstPart = multipartObjectStorage.uploadPart(
            UploadPartRequest(upload, 1, UploadRequest.fromBytes(nonFinalChunk, upload.key))
        )
        val secondPart = multipartObjectStorage.uploadPart(
            UploadPartRequest(upload, 2, UploadRequest.fromBytes(finalChunk, upload.key))
        )

        multipartObjectStorage.completeMultipartUpload(
            CompleteMultipartUploadRequest(upload, listOf(firstPart.part, secondPart.part))
        )
        return upload.key
    } catch (e: RuntimeException) {
        multipartObjectStorage.abortMultipartUpload(AbortMultipartUploadRequest(upload))
        throw e
    }
}

String uploadVideo(String key, byte[] nonFinalChunk, byte[] finalChunk) {
    def createResponse = multipartObjectStorage.createMultipartUpload(
        new CreateMultipartUploadRequest(key, 'video/mp4')
    )
    def upload = createResponse.upload

    try {
        def firstPart = multipartObjectStorage.uploadPart(
            new UploadPartRequest(upload, 1, UploadRequest.fromBytes(nonFinalChunk, upload.key))
        )
        def secondPart = multipartObjectStorage.uploadPart(
            new UploadPartRequest(upload, 2, UploadRequest.fromBytes(finalChunk, upload.key))
        )

        multipartObjectStorage.completeMultipartUpload(
            new CompleteMultipartUploadRequest(upload, [firstPart.part, secondPart.part])
        )
        upload.key
    } catch (RuntimeException e) {
        multipartObjectStorage.abortMultipartUpload(new AbortMultipartUploadRequest(upload))
        throw e
    }
}

@Singleton
public class BucketService {

    private final BucketOperations<?> bucketOperations;
    private final ReactiveBucketOperations<?> reactiveBucketOperations;

    public BucketService(@Named("default") BucketOperations<?> bucketOperations,
                         @Named("default") ReactiveBucketOperations<?> reactiveBucketOperations) {
        this.bucketOperations = bucketOperations;
        this.reactiveBucketOperations = reactiveBucketOperations;
    }

}

@Singleton
open class BucketService(
    @param:Named("default") private val bucketOperations: BucketOperations<*>,
    @param:Named("default") private val reactiveBucketOperations: ReactiveBucketOperations<*>
) {

}

@Singleton
class BucketService {

    final BucketOperations<?> bucketOperations
    final ReactiveBucketOperations<?> reactiveBucketOperations

    BucketService(@Named("default") BucketOperations<?> bucketOperations,
                  @Named("default") ReactiveBucketOperations<?> reactiveBucketOperations) {
        this.bucketOperations = bucketOperations
        this.reactiveBucketOperations = reactiveBucketOperations
    }

}

public void manageBucket(String name) {
    bucketOperations.create(name);
    boolean exists = bucketOperations.exists(name);
    bucketOperations.retrieve(name).ifPresent(bucket -> {
        System.out.println(bucket.name());
    });
    if (exists) {
        bucketOperations.delete(name);
    }
}

open fun manageBucket(name: String) {
    bucketOperations.create(name)
    val exists = bucketOperations.exists(name)
    bucketOperations.retrieve(name).ifPresent { bucket -> println(bucket.name()) }
    if (exists) {
        bucketOperations.delete(name)
    }
}

void manageBucket(String name) {
    bucketOperations.create(name)
    boolean exists = bucketOperations.exists(name)
    bucketOperations.retrieve(name).ifPresent { bucket -> println(bucket.name()) }
    if (exists) {
        bucketOperations.delete(name)
    }
}

public void manageBucketReactive(String name) {
    Publisher<Void> create = reactiveBucketOperations.create(name);
    Publisher<Boolean> exists = reactiveBucketOperations.exists(name);
}

open fun manageBucketReactive(name: String) {
    val create: Publisher<Void> = reactiveBucketOperations.create(name)
    val exists: Publisher<Boolean> = reactiveBucketOperations.exists(name)
}

void manageBucketReactive(String name) {
    Publisher<Void> create = reactiveBucketOperations.create(name)
    Publisher<Boolean> exists = reactiveBucketOperations.exists(name)
}