Add Java and Kotlin Getting started

.ci/doc/templates/empty.tpl.kt

@@ -0,0 +1 @@
+[snippet-code]

doc/1/controllers/bulk/index.md

@@ -0,0 +1,8 @@
+---
+code: true
+type: branch
+title: Bulk
+description: Bulk Controller
+---
+
+# Bulk Controller

doc/1/core-classes/search-result/next/index.md

@@ -75,7 +75,6 @@ Above that limit, any call to `next` throws an Exception.
 
 <<< ./snippets/fromsize-java.java
 
-
 :::
 ::: tab Kotlin
 
@@ -143,4 +142,4 @@ Above that limit, any call to `next` throws an Exception.
 <<< ./snippets/fromsize-kotlin.kt
 
 :::
-:::.
+::::

doc/1/getting-started/index.md

@@ -0,0 +1,6 @@
+---
+code: false
+type: branch
+order: 0
+title: Getting Started
+---

doc/1/getting-started/java/index.md

@@ -0,0 +1,149 @@
+---
+code: false
+type: page
+title: Java
+description: Java Getting started
+order: 99
+---
+
+# Getting Started
+
+In this tutorial you will learn how to install the Kuzzle **Jvm SDK**.
+This page shows examples of scripts that **store** documents in Kuzzle, and of scripts that subcribe to real-time **notifications** for each new document created.
+
+::: success
+Before proceeding, please make sure your system meets the following requirements:
+
+- **Oracle JDK or OpenJDK** version 8 or higher ([OpenJDK installation instructions](https://openjdk.java.net/install/))
+- A running Kuzzle Server ([Kuzzle installation guide](/core/2/guides/essentials/installing-kuzzle))
+
+:::
+
+
+::: info
+Having trouble? Get in touch with us on [Discord](http://join.discord.kuzzle.io)!
+:::
+
+## Installation
+
+You can find the SDK JARs directly on [bintray](https://bintray.com/kuzzle/maven/sdk-jvm). Download and add it to your classpath.
+
+::: info
+The following examples are made to be executed without any IDE.
+If you're using Eclipse, IntelliJ or another Java IDE, you need to add the SDK as a project dependency in your classpath.
+:::
+
+### Installing on Android using gradle
+
+In your app build.gradle add the following line and sync.
+
+### Maven:
+
+```xml
+<dependency>
+  <groupId>io.kuzzle</groupId>
+  <artifactId>sdk-jvm</artifactId>
+  <version>1.0.0</version>
+  <type>pom</type>
+</dependency>
+```
+
+### Gradle:
+
+```groovy
+implementation 'io.kuzzle:sdk-jvm:1.0.0'
+```
+
+### Ivy:
+
+```html
+<dependency org='io.kuzzle' name='sdk-jvm' rev='1.0.0'>
+  <artifact name='sdk-jvm' ext='pom' ></artifact>
+</dependency>
+```
+
+## First connection
+
+Initialize a new Java project, create a `GettingStartedFirstConnection.java` file and start by adding the code below:
+
+<<< ./snippets/firstconnection.java
+
+This program initializes the Kuzzle Server storage by creating a index, and a collection inside it
+Run the program with the following command:
+
+```bash
+$ javac -classpath ./path/to/the/sdk.jar GettingStartedFirstConnection.java
+$ java -classpath .:./path/to/the/sdk.jar GettingStartedFirstConnection
+Connected!
+Index nyc-open-data created!
+Collection yellow-taxi created!
+```
+
+Congratulations, you performed your first connection to Kuzzle Server via a Java program.
+You now know how to:
+
+- Instantiate Kuzzle SDK and connect to Kuzzle Server using a specific protocol (here `websocket`)
+- Create a index
+- Create a collection within an existing index
+
+## Create your first document
+
+Now that you successfully connected to your Kuzzle Server instance, and created an index and a collection, it's time to manipulate some data.
+
+Here is how Kuzzle structures its storage space:
+
+- indexes contain collections
+- collections contain documents
+  Create a `GettingStartedStorage.java` file in the playground and add this code:
+
+<<< ./snippets/document.java
+
+As you did before, build and run your program:
+
+```bash
+$ javac -classpath ./path/to/the/sdk.jar  GettingStartedStorage.java
+$ java -classpath .:./path/to/the/sdk.jar GettingStartedStorage
+Connected!
+New document added to yellow-taxi collection!
+```
+
+You can perform other actions such as [delete](/sdk/jvm/1/controllers/document/delete), [replace](/sdk/jvm/1/controllers/document/replace) or [search](/sdk/jvm/1/controllers/document/search) documents. There are also other ways to interact with Kuzzle like our [Admin Console](/core/2/guides/essentials/admin-console), the [Kuzzle HTTP API](/core/2/api/essentials/connecting-to-kuzzle) or by using your [own protocol](/core/2/protocols/essentials/getting-started).
+
+Now you know how to:
+
+- Store documents in a Kuzzle Server, and access those
+
+## Subscribe to realtime document notifications (pub/sub)
+
+Time to use realtime with Kuzzle. Create a new file `GettingStartedRealtime.java` with the following code:
+
+<<< ./snippets/realtime.java
+
+This program subscribes to changes made to documents with a `license` field set to `B`, within the `yellow-taxi` collection. Whenever a document matching the provided filters changes, a new notification is received from Kuzzle.
+
+Build and run your program:
+
+```bash
+$ javac -classpath ./path/to/the/sdk.jar GettingStartedRealtime.java
+$ java -classpath .:./path/to/the/sdk.jar GettingStartedRealtime
+Connected!
+Successfully subscribing!
+New document added to yellow-taxi collection!
+New created document notification: [Document content as ConcurrentHashMap]
+```
+
+You should see document content as a `ConcurrentHashMap`.
+
+Now, you know how to:
+
+- Create realtime filters
+- Subscribe to notifications
+
+## Where do we go from here?
+
+Now that you're more familiar with the Jvm SDK, you can dive even deeper to learn how to leverage its full capabilities:
+
+- discover what this SDK has to offer by browsing other sections of this documentation
+- learn how to use [Koncorde](/core/2/guides/cookbooks/realtime-api) to create incredibly fine-grained and blazing-fast subscriptions
+- follow our guide to learn how to perform [basic authentication](/core/2/guides/essentials/user-authentication#local-strategy)
+- follow our guide to learn how to [manage users and how to set up fine-grained access control](/core/2/guides/essentials/security)

doc/1/getting-started/java/snippets/document-java.java

@@ -0,0 +1,46 @@
+import io.kuzzle.sdk.*;
+import io.kuzzle.sdk.protocol.WebSocket;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+public class SnippetTest {
+  private static Kuzzle kuzzle;
+
+  public static void main(String[] args) {
+
+    try {
+      // Creates a WebSocket connection.
+      // Replace "kuzzle" with
+      // your Kuzzle hostname like "localhost"
+
+      WebSocket ws = new WebSocket("kuzzle");
+
+      // Instantiates a Kuzzle client
+      kuzzle = new Kuzzle(ws);
+
+      // Connects to the server.
+      kuzzle.connect();
+      System.out.println("Connected!");
+    } catch(Exception e){
+      e.printStackTrace();
+    }
+
+    // New document content
+    ConcurrentHashMap<String, Object> content = new ConcurrentHashMap<>();
+    content.put("name", "John");
+    content.put("birthday", "1995-11-27");
+    content.put("license", "B");
+
+    // Stores the document in the "yellow-taxi" collection.
+    try {
+      kuzzle.getDocumentController()
+          .create( "nyc-open-data", "yellow-taxi", content).get();
+      System.out.println("New document added to the yellow-taxi collection!");
+    } catch(Exception e){
+      e.printStackTrace();
+    }
+
+    // Disconnects the SDK.
+    kuzzle.disconnect();
+  }
+}

doc/1/getting-started/java/snippets/document-java.test.yml

@@ -0,0 +1,9 @@
+name: java-gettingstarted#storage
+description: Data manipulation
+hooks:
+  before: curl -X POST kuzzle:7512/nyc-open-data/_create ; curl -X PUT kuzzle:7512/nyc-open-data/yellow-taxi/; curl -X DELETE kuzzle:7512/nyc-open-data/yellow-taxi/some-id
+  after:
+template: empty
+expected:
+  - Connected!
+  - New document added to the yellow-taxi collection!

doc/1/getting-started/java/snippets/firstconnection-java.java

@@ -0,0 +1,48 @@
+import io.kuzzle.sdk.*;
+import io.kuzzle.sdk.protocol.WebSocket;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+public class SnippetTest {
+  private static Kuzzle kuzzle;
+
+  public static void main(String[] args) {
+
+    try {
+      // Creates a WebSocket connection.
+      // Replace "kuzzle" with
+      // your Kuzzle hostname like "localhost"
+
+      WebSocket ws = new WebSocket("kuzzle");
+
+      // Instantiates a Kuzzle client
+      kuzzle = new Kuzzle(ws);
+
+      // Connects to the server.
+      kuzzle.connect();
+      System.out.println("Connected!");
+    } catch(Exception e){
+      e.printStackTrace();
+    }
+
+    // Freshly installed Kuzzle servers are empty: we need to create
+    // a new index.
+    try {
+      kuzzle.getIndexController().create("nyc-open-data").get();
+      System.out.println("Index nyc-open-data created!");
+    } catch(Exception e){
+      e.printStackTrace();
+    }
+
+    // Creates a collection
+    try {
+      kuzzle.getCollectionController().create("nyc-open-data", "yellow-taxi").get();
+      System.out.println("Collection yellow-taxi created!");
+    } catch(Exception e){
+      e.printStackTrace();
+    }
+
+    // Disconnects the SDK
+    kuzzle.disconnect();
+  }
+}

doc/1/getting-started/java/snippets/firstconnection-java.test.yml

@@ -0,0 +1,10 @@
+name: java-gettingstarted#firstconnection
+description: First connection
+hooks:
+  before: curl -X DELETE kuzzle:7512/nyc-open-data
+  after:
+template: empty
+expected:
+  - Connected!
+  - Index nyc-open-data created!
+  - Collection yellow-taxi created!

doc/1/getting-started/java/snippets/realtime-java.java

@@ -0,0 +1,64 @@
+import io.kuzzle.sdk.*;
+import io.kuzzle.sdk.protocol.WebSocket;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+public class SnippetTest {
+  private static Kuzzle kuzzle;
+
+  public static void main(String[] args) {
+
+    try {
+      // Creates a WebSocket connection.
+      // Replace "kuzzle" with
+      // your Kuzzle hostname like "localhost"
+
+      WebSocket ws = new WebSocket("kuzzle");
+
+      // Instantiates a Kuzzle client
+      kuzzle = new Kuzzle(ws);
+
+      // Connects to the server.
+      kuzzle.connect();
+      System.out.println("Connected!");
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+    // Subscribes to notifications for drivers having a "B" driver license.
+    ConcurrentHashMap<String, Object> filters = new ConcurrentHashMap<>();
+    ConcurrentHashMap<String, Object> equals = new ConcurrentHashMap<>();
+    equals.put("license", "B");
+    filters.put("equals", equals);
+
+    try {
+      // Sends the subscription
+      kuzzle.getRealtimeController()
+          .subscribe("nyc-open-data", "yellow-taxi", filters, notification -> {
+            ConcurrentHashMap<String, Object> content = ((ConcurrentHashMap<String, Object>)(notification.getResult()));
+            System.out.println("New created document notification: " + content);
+          }).get();
+      System.out.println("Successfully subscribed!");
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+    // Writes a new document. This triggers a notification
+    // sent to our subscription.
+    ConcurrentHashMap<String, Object> content = new ConcurrentHashMap<>();
+    content.put("name", "John");
+    content.put("birthday", "1995-11-27");
+    content.put("license", "B");
+
+    try {
+      kuzzle.getDocumentController()
+          .create("nyc-open-data", "yellow-taxi", content).get();
+      System.out.println("New document added to the yellow-taxi collection!");
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+
+    // Disconnects the SDK.
+    kuzzle.disconnect();
+  }
+}

doc/1/getting-started/java/snippets/realtime-java.test.yml

@@ -0,0 +1,10 @@
+name: java-gettingstarted#realtime
+description: Realtime interactions
+hooks:
+  before: curl -X POST kuzzle:7512/nyc-open-data/_create ; curl -X PUT kuzzle:7512/nyc-open-data/yellow-taxi/
+  after:
+template: empty
+expected:
+  - Connected!
+  - Successfully subscribed!
+  - ^New created document notification:.*$