Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.
Zextras Carbonio Workstream Collaboration Chats HTTP APIs definition.
Base URLs:
listRoom
Code samples
curl -X GET http://localhost:10000/rooms \
-H 'Accept: application/json'
GET http://localhost:10000/rooms HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get 'http://localhost:10000/rooms' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.get('http://localhost:10000/rooms' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/rooms" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/rooms' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /rooms
Retrieves a list of every room the user has access to
Parameters
Name
In
Type
Required
Description
extraFields
query
array[string]
false
Rooms extra fields
Enumerated Values
Parameter
Value
extraFields
members
extraFields
settings
Example responses
200 Response
[
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43" ,
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"rank" : 0 ,
"meetingId" : "bba231d0-d474-4cf9-bb49-b12d0cb2a3ed" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"updatedAt" : "2019-08-24T14:15:22Z" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"children" : [
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43" ,
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"rank" : 0 ,
"meetingId" : "bba231d0-d474-4cf9-bb49-b12d0cb2a3ed" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"updatedAt" : "2019-08-24T14:15:22Z" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"children" : [],
"members" : [
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
],
"userSettings" : {
"muted" : true ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
}
],
"members" : [
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
],
"userSettings" : {
"muted" : true ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
}
]
Responses
Status
Meaning
Description
Schema
200
OK
List of every room that the user has access to
Inline
Response Schema
Status Code 200
Name
Type
Required
Restrictions
Description
anonymous
[allOf]
false
none
[Room data]
allOf
Name
Type
Required
Restrictions
Description
» anonymous
RoomCreationFields
false
none
Room fields for its creation
»» membersIds
[string]
false
none
members identifiers list to be subscribed to the room
allOf
Name
Type
Required
Restrictions
Description
»» anonymous
RoomEditableFields
false
none
Room fields that can be updated
»»» name
string
false
none
room name
»»» description
string
false
none
room description
and
Name
Type
Required
Restrictions
Description
»» anonymous
object
false
none
none
»»» type
RoomType
false
none
Managed room types
»»» parentId
string(uuid)
false
none
identifier of the referenced workspace
and
Name
Type
Required
Restrictions
Description
» anonymous
object
false
none
none
»» id
string(uuid)
false
read-only
room identifier
»» rank
integer
false
read-only
number that defines the sorting position for workspaces room
»» meetingId
string(uuid)
false
read-only
identifier of associated meeting
»» createdAt
string(date-time)
false
read-only
entity creation date
»» updatedAt
string(date-time)
false
read-only
entity update date
»» pictureUpdatedAt
string(date-time)
false
read-only
room profile picture update timestamp, returned only if the room picture was set at least once
»» children
[allOf]
false
none
Room data
»» members
[Member ]
false
none
list of users subscribed to the room
»»» userId
string(uuid)
true
none
user identifier
»»» owner
boolean
true
none
indicates whether it is the owner
»» userSettings
RoomUserSettings
false
none
Preferences that an user has set for a room
»»» muted
boolean
true
none
indicates whether the user has muted
»»» clearedAt
string(date-time)
true
none
room clear history date, returned only if the room clear history has been cleared at least once
Enumerated Values
Property
Value
type
group
type
one_to_one
type
workspace
type
channel
type
temporary
This operation does not require authentication
insertRoom
Code samples
curl -X POST http://localhost:10000/rooms \
-H 'Content-Type: application/json' \
-H 'Accept: application/json'
POST http://localhost:10000/rooms HTTP/1.1
Host : localhost:10000
Content-Type : application/json
Accept : application/json
const inputBody = '{
"membersIds": [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name": "string",
"description": "string",
"type": "group",
"parentId": "70850378-7d3c-4f45-91b7-942d4dfbbd43"
}' ;
const headers = {
'Content-Type' :'application/json' ,
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms' ,
{
method : 'POST' ,
body : inputBody,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const inputBody = {
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43"
};
const headers = {
'Content-Type' :'application/json' ,
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms' ,
{
method : 'POST' ,
body : JSON .stringify(inputBody),
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json' ,
'Accept' => 'application/json'
}
result = RestClient.post 'http://localhost:10000/rooms' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type' : 'application/json' ,
'Accept' : 'application/json'
}
r = requests.post('http://localhost:10000/rooms' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Content-Type" : []string {"application/json" },
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("POST" , "http://localhost:10000/rooms" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
'Accept' => 'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('POST' ,'http://localhost:10000/rooms' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
POST /rooms
Insert a room of the specified type
Inserts a room of the specified type. The user performing the request will be included in the final members
list if not specified. If the room is a one to one, only a single member can be specified and name and
description are replaced with an empty string. If the room is not a one to
one, there must be at least two members specified.
Body parameter
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43"
}
Parameters
Example responses
201 Response
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43" ,
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"rank" : 0 ,
"meetingId" : "bba231d0-d474-4cf9-bb49-b12d0cb2a3ed" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"updatedAt" : "2019-08-24T14:15:22Z" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"children" : [
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43" ,
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"rank" : 0 ,
"meetingId" : "bba231d0-d474-4cf9-bb49-b12d0cb2a3ed" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"updatedAt" : "2019-08-24T14:15:22Z" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"children" : [],
"members" : [
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
],
"userSettings" : {
"muted" : true ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
}
],
"members" : [
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
],
"userSettings" : {
"muted" : true ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
}
Responses
Status
Meaning
Description
Schema
201
Created
The newly created room
Room
400
Bad Request
The request had wrong or missing parameters
None
403
Forbidden
The requester could not access the resource
None
409
Conflict
The request conflict with the current state
None
This operation does not require authentication
getRoom
Code samples
curl -X GET http://localhost:10000/rooms/{roomId} \
-H 'Accept: application/json'
GET http://localhost:10000/rooms/{roomId} HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get 'http://localhost:10000/rooms/{roomId}' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.get('http://localhost:10000/rooms/{roomId}' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/rooms/{roomId}" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/rooms/{roomId}' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /rooms/{roomId}
Retrieves the requested room
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
Example responses
200 Response
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43" ,
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"rank" : 0 ,
"meetingId" : "bba231d0-d474-4cf9-bb49-b12d0cb2a3ed" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"updatedAt" : "2019-08-24T14:15:22Z" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"children" : [
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43" ,
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"rank" : 0 ,
"meetingId" : "bba231d0-d474-4cf9-bb49-b12d0cb2a3ed" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"updatedAt" : "2019-08-24T14:15:22Z" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"children" : [],
"members" : [
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
],
"userSettings" : {
"muted" : true ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
}
],
"members" : [
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
],
"userSettings" : {
"muted" : true ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
}
Responses
Status
Meaning
Description
Schema
200
OK
Requested room
Room
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
updateRoom
Code samples
curl -X PUT http://localhost:10000/rooms/{roomId} \
-H 'Content-Type: application/json' \
-H 'Accept: application/json'
PUT http://localhost:10000/rooms/{roomId} HTTP/1.1
Host : localhost:10000
Content-Type : application/json
Accept : application/json
const inputBody = '{
"name": "string",
"description": "string"
}' ;
const headers = {
'Content-Type' :'application/json' ,
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}' ,
{
method : 'PUT' ,
body : inputBody,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const inputBody = {
"name" : "string" ,
"description" : "string"
};
const headers = {
'Content-Type' :'application/json' ,
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}' ,
{
method : 'PUT' ,
body : JSON .stringify(inputBody),
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json' ,
'Accept' => 'application/json'
}
result = RestClient.put 'http://localhost:10000/rooms/{roomId}' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type' : 'application/json' ,
'Accept' : 'application/json'
}
r = requests.put('http://localhost:10000/rooms/{roomId}' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Content-Type" : []string {"application/json" },
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("PUT" , "http://localhost:10000/rooms/{roomId}" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
'Accept' => 'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('PUT' ,'http://localhost:10000/rooms/{roomId}' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
PUT /rooms/{roomId}
Updates a room information
Body parameter
{
"name" : "string" ,
"description" : "string"
}
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
body
body
RoomEditableFields
true
room fields to update
Example responses
200 Response
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43" ,
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"rank" : 0 ,
"meetingId" : "bba231d0-d474-4cf9-bb49-b12d0cb2a3ed" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"updatedAt" : "2019-08-24T14:15:22Z" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"children" : [
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43" ,
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"rank" : 0 ,
"meetingId" : "bba231d0-d474-4cf9-bb49-b12d0cb2a3ed" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"updatedAt" : "2019-08-24T14:15:22Z" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"children" : [],
"members" : [
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
],
"userSettings" : {
"muted" : true ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
}
],
"members" : [
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
],
"userSettings" : {
"muted" : true ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
}
Responses
Status
Meaning
Description
Schema
200
OK
Updated room
Room
400
Bad Request
The request had wrong or missing parameters
None
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
deleteRoom
Code samples
curl -X DELETE http://localhost:10000/rooms/{roomId}
DELETE http://localhost:10000/rooms/{roomId} HTTP/1.1
Host : localhost:10000
fetch('http://localhost:10000/rooms/{roomId}' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
fetch('http://localhost:10000/rooms/{roomId}' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
result = RestClient.delete 'http://localhost:10000/rooms/{roomId}' ,
params: {
}
p JSON.parse(result)
import requests
r = requests.delete('http://localhost:10000/rooms/{roomId}' )
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("DELETE" , "http://localhost:10000/rooms/{roomId}" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
request('DELETE' ,'http://localhost:10000/rooms/{roomId}' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
DELETE /rooms/{roomId}
Deletes the specified room
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
Responses
Status
Meaning
Description
Schema
204
No Content
Room was deleted correctly or it never existed
None
403
Forbidden
The requester could not access the resource
None
This operation does not require authentication
getRoomPicture
Code samples
curl -X GET http://localhost:10000/rooms/{roomId}/picture \
-H 'Accept: application/octet-stream'
GET http://localhost:10000/rooms/{roomId}/picture HTTP/1.1
Host : localhost:10000
Accept : application/octet-stream
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/rooms/{roomId}/picture' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/rooms/{roomId}/picture' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/octet-stream'
}
result = RestClient.get 'http://localhost:10000/rooms/{roomId}/picture' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/octet-stream'
}
r = requests.get('http://localhost:10000/rooms/{roomId}/picture' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/picture" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/octet-stream" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/rooms/{roomId}/picture" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/octet-stream' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/rooms/{roomId}/picture' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /rooms/{roomId}/picture
Retrieves the room picture
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
Example responses
200 Response
Responses
Status
Meaning
Description
Schema
200
OK
The requested picture
string
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
updateRoomPicture
Code samples
curl -X PUT http://localhost:10000/rooms/{roomId}/picture \
-H 'Content-Type: application/octet-stream' \
-H 'fileName: string' \
-H 'mimeType: string' \
-H 'Content-Length: null'
PUT http://localhost:10000/rooms/{roomId}/picture HTTP/1.1
Host : localhost:10000
Content-Type : application/octet-stream
fileName: string
mimeType: string
Content-Length: null
const inputBody = 'string' ;
const headers = {
'Content-Type' :'application/octet-stream' ,
'fileName' :'string' ,
'mimeType' :'string' ,
'Content-Length' :null
};
fetch('http://localhost:10000/rooms/{roomId}/picture' ,
{
method : 'PUT' ,
body : inputBody,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const inputBody = string;
const headers = {
'Content-Type' :'application/octet-stream' ,
'fileName' :'string' ,
'mimeType' :'string' ,
'Content-Length' :null
};
fetch('http://localhost:10000/rooms/{roomId}/picture' ,
{
method : 'PUT' ,
body : JSON .stringify(inputBody),
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/octet-stream' ,
'fileName' => 'string' ,
'mimeType' => 'string' ,
'Content-Length' => null
}
result = RestClient.put 'http://localhost:10000/rooms/{roomId}/picture' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type' : 'application/octet-stream' ,
'fileName' : 'string' ,
'mimeType' : 'string' ,
'Content-Length' : null
}
r = requests.put('http://localhost:10000/rooms/{roomId}/picture' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/picture" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Content-Type" : []string {"application/octet-stream" },
"fileName" : []string {"string" },
"mimeType" : []string {"string" },
"Content-Length" : []string {"null" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("PUT" , "http://localhost:10000/rooms/{roomId}/picture" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/octet-stream' ,
'fileName' => 'string' ,
'mimeType' => 'string' ,
'Content-Length' => 'null' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('PUT' ,'http://localhost:10000/rooms/{roomId}/picture' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
PUT /rooms/{roomId}/picture
Uploads and sets a new room picture
Body parameter
string
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
fileName
header
string
true
file name encoded to unicode
mimeType
header
string
true
content type
Content-Length
header
long
true
content length
body
body
string(binary)
true
image to set
Responses
Status
Meaning
Description
Schema
204
No Content
Room picture was changed correctly
None
This operation does not require authentication
deleteRoomPicture
Code samples
curl -X DELETE http://localhost:10000/rooms/{roomId}/picture
DELETE http://localhost:10000/rooms/{roomId}/picture HTTP/1.1
Host : localhost:10000
fetch('http://localhost:10000/rooms/{roomId}/picture' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
fetch('http://localhost:10000/rooms/{roomId}/picture' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
result = RestClient.delete 'http://localhost:10000/rooms/{roomId}/picture' ,
params: {
}
p JSON.parse(result)
import requests
r = requests.delete('http://localhost:10000/rooms/{roomId}/picture' )
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/picture" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("DELETE" , "http://localhost:10000/rooms/{roomId}/picture" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
request('DELETE' ,'http://localhost:10000/rooms/{roomId}/picture' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
DELETE /rooms/{roomId}/picture
Delete the room picture
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
Responses
Status
Meaning
Description
Schema
204
No Content
Room picture was deleted correctly
None
401
Unauthorized
User not authorized
None
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
muteRoom
Code samples
curl -X PUT http://localhost:10000/rooms/{roomId}/mute
PUT http://localhost:10000/rooms/{roomId}/mute HTTP/1.1
Host : localhost:10000
fetch('http://localhost:10000/rooms/{roomId}/mute' ,
{
method : 'PUT'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
fetch('http://localhost:10000/rooms/{roomId}/mute' ,
{
method : 'PUT'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
result = RestClient.put 'http://localhost:10000/rooms/{roomId}/mute' ,
params: {
}
p JSON.parse(result)
import requests
r = requests.put('http://localhost:10000/rooms/{roomId}/mute' )
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/mute" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("PUT" , "http://localhost:10000/rooms/{roomId}/mute" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
request('PUT' ,'http://localhost:10000/rooms/{roomId}/mute' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
PUT /rooms/{roomId}/mute
Mutes notification for the specified room
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
Responses
Status
Meaning
Description
Schema
204
No Content
Room was muted correctly
None
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
unmuteRoom
Code samples
curl -X DELETE http://localhost:10000/rooms/{roomId}/mute
DELETE http://localhost:10000/rooms/{roomId}/mute HTTP/1.1
Host : localhost:10000
fetch('http://localhost:10000/rooms/{roomId}/mute' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
fetch('http://localhost:10000/rooms/{roomId}/mute' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
result = RestClient.delete 'http://localhost:10000/rooms/{roomId}/mute' ,
params: {
}
p JSON.parse(result)
import requests
r = requests.delete('http://localhost:10000/rooms/{roomId}/mute' )
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/mute" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("DELETE" , "http://localhost:10000/rooms/{roomId}/mute" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
request('DELETE' ,'http://localhost:10000/rooms/{roomId}/mute' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
DELETE /rooms/{roomId}/mute
Unmutes notification for the specified room
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
Responses
Status
Meaning
Description
Schema
204
No Content
Room was unmuted correctly
None
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
clearRoomHistory
Code samples
curl -X PUT http://localhost:10000/rooms/{roomId}/clear \
-H 'Accept: application/json'
PUT http://localhost:10000/rooms/{roomId}/clear HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/clear' ,
{
method : 'PUT' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/clear' ,
{
method : 'PUT' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.put 'http://localhost:10000/rooms/{roomId}/clear' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.put('http://localhost:10000/rooms/{roomId}/clear' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/clear" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("PUT" , "http://localhost:10000/rooms/{roomId}/clear" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('PUT' ,'http://localhost:10000/rooms/{roomId}/clear' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
PUT /rooms/{roomId}/clear
Clears all messages for the specified room
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
Example responses
200 Response
{
"clearedAt" : "2019-08-24T14:15:22Z"
}
Responses
Status
Meaning
Description
Schema
200
OK
Cleaning date of messages
ClearedDate
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
updateWorkspacesRank
Code samples
curl -X PUT http://localhost:10000/rooms/workspaces/rank \
-H 'Content-Type: application/json'
PUT http://localhost:10000/rooms/workspaces/rank HTTP/1.1
Host : localhost:10000
Content-Type : application/json
const inputBody = '[
{
"roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
"rank": 0
}
]' ;
const headers = {
'Content-Type' :'application/json'
};
fetch('http://localhost:10000/rooms/workspaces/rank' ,
{
method : 'PUT' ,
body : inputBody,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const inputBody = [
{
"roomId" : "c3631f02-ff67-42b8-8775-18c47f52a678" ,
"rank" : 0
}
];
const headers = {
'Content-Type' :'application/json'
};
fetch('http://localhost:10000/rooms/workspaces/rank' ,
{
method : 'PUT' ,
body : JSON .stringify(inputBody),
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json'
}
result = RestClient.put 'http://localhost:10000/rooms/workspaces/rank' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type' : 'application/json'
}
r = requests.put('http://localhost:10000/rooms/workspaces/rank' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/workspaces/rank" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Content-Type" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("PUT" , "http://localhost:10000/rooms/workspaces/rank" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('PUT' ,'http://localhost:10000/rooms/workspaces/rank' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
PUT /rooms/workspaces/rank
Updates the workspaces order for the authenticated user
Body parameter
[
{
"roomId" : "c3631f02-ff67-42b8-8775-18c47f52a678" ,
"rank" : 0
}
]
Parameters
Name
In
Type
Required
Description
body
body
RoomRanks
true
workspaces list with their rank
Responses
Status
Meaning
Description
Schema
204
No Content
workspaces’s order is updated
None
This operation does not require authentication
updateChannelsRank
Code samples
curl -X PUT http://localhost:10000/rooms/workspaces/{workspaceId}/channels/rank \
-H 'Content-Type: application/json'
PUT http://localhost:10000/rooms/workspaces/{workspaceId}/channels/rank HTTP/1.1
Host : localhost:10000
Content-Type : application/json
const inputBody = '[
{
"roomId": "c3631f02-ff67-42b8-8775-18c47f52a678",
"rank": 0
}
]' ;
const headers = {
'Content-Type' :'application/json'
};
fetch('http://localhost:10000/rooms/workspaces/{workspaceId}/channels/rank' ,
{
method : 'PUT' ,
body : inputBody,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const inputBody = [
{
"roomId" : "c3631f02-ff67-42b8-8775-18c47f52a678" ,
"rank" : 0
}
];
const headers = {
'Content-Type' :'application/json'
};
fetch('http://localhost:10000/rooms/workspaces/{workspaceId}/channels/rank' ,
{
method : 'PUT' ,
body : JSON .stringify(inputBody),
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json'
}
result = RestClient.put 'http://localhost:10000/rooms/workspaces/{workspaceId}/channels/rank' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type' : 'application/json'
}
r = requests.put('http://localhost:10000/rooms/workspaces/{workspaceId}/channels/rank' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/workspaces/{workspaceId}/channels/rank" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Content-Type" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("PUT" , "http://localhost:10000/rooms/workspaces/{workspaceId}/channels/rank" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('PUT' ,'http://localhost:10000/rooms/workspaces/{workspaceId}/channels/rank' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
PUT /rooms/workspaces/{workspaceId}/channels/rank
Updates the channels order in the workspace
Body parameter
[
{
"roomId" : "c3631f02-ff67-42b8-8775-18c47f52a678" ,
"rank" : 0
}
]
Parameters
Name
In
Type
Required
Description
workspaceId
path
string(uuid)
true
workspace identifier
body
body
RoomRanks
true
channels list with their rank
Responses
Status
Meaning
Description
Schema
204
No Content
channels’s order is updated
None
This operation does not require authentication
insertRoomMember
Code samples
curl -X POST http://localhost:10000/rooms/{roomId}/members \
-H 'Content-Type: application/json' \
-H 'Accept: application/json'
POST http://localhost:10000/rooms/{roomId}/members HTTP/1.1
Host : localhost:10000
Content-Type : application/json
Accept : application/json
const inputBody = '{
"userId": "2c4a230c-5085-4924-a3e1-25fb4fc5965b",
"owner": false,
"historyCleared": true
}' ;
const headers = {
'Content-Type' :'application/json' ,
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/members' ,
{
method : 'POST' ,
body : inputBody,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const inputBody = {
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false ,
"historyCleared" : true
};
const headers = {
'Content-Type' :'application/json' ,
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/members' ,
{
method : 'POST' ,
body : JSON .stringify(inputBody),
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json' ,
'Accept' => 'application/json'
}
result = RestClient.post 'http://localhost:10000/rooms/{roomId}/members' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type' : 'application/json' ,
'Accept' : 'application/json'
}
r = requests.post('http://localhost:10000/rooms/{roomId}/members' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/members" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Content-Type" : []string {"application/json" },
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("POST" , "http://localhost:10000/rooms/{roomId}/members" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
'Accept' => 'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('POST' ,'http://localhost:10000/rooms/{roomId}/members' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
POST /rooms/{roomId}/members
Adds or invites the specified user to the room
Adds the specified user to the room. This can only be performed by an owner of the given room
Body parameter
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false ,
"historyCleared" : true
}
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
body
body
MemberToInsert
true
member to add or invite
Example responses
201 Response
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
Responses
Status
Meaning
Description
Schema
201
Created
The member added or invited
MemberInserted
400
Bad Request
The request had wrong or missing parameters
None
403
Forbidden
The requester could not access the resource
None
This operation does not require authentication
listRoomAttachmentInfo
Code samples
curl -X GET http://localhost:10000/rooms/{roomId}/attachments \
-H 'Accept: application/json'
GET http://localhost:10000/rooms/{roomId}/attachments HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/attachments' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/attachments' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get 'http://localhost:10000/rooms/{roomId}/attachments' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.get('http://localhost:10000/rooms/{roomId}/attachments' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/attachments" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/rooms/{roomId}/attachments" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/rooms/{roomId}/attachments' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /rooms/{roomId}/attachments
Retrieves paged list of metadata of every attachment uploaded to the room and the filter for the next page
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
itemsNumber
query
integer
false
number of page items
filter
query
string
false
pagination filter
Example responses
200 Response
{
"filter" : "string" ,
"attachments" : [
{
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"name" : "string" ,
"size" : 0 ,
"mimeType" : "string" ,
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"roomId" : "c3631f02-ff67-42b8-8775-18c47f52a678" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"area" : "string"
}
]
}
Responses
Status
Meaning
Description
Schema
200
OK
Paged list of metadata of every attachment uploaded to the room
AttachmentsPagination
401
Unauthorized
User not authorized
None
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
insertAttachment
Code samples
curl -X POST http://localhost:10000/rooms/{roomId}/attachments \
-H 'Content-Type: application/octet-stream' \
-H 'Accept: application/json' \
-H 'fileName: string' \
-H 'mimeType: string' \
-H 'description: string' \
-H 'messageId: string' \
-H 'replyId: string' \
-H 'area: string' \
-H 'Content-Length: null'
POST http://localhost:10000/rooms/{roomId}/attachments HTTP/1.1
Host : localhost:10000
Content-Type : application/octet-stream
Accept : application/json
fileName : string
mimeType : string
description : string
messageId : string
replyId : string
area : string
Content-Length : null
const inputBody = 'string' ;
const headers = {
'Content-Type' :'application/octet-stream' ,
'Accept' :'application/json' ,
'fileName' :'string' ,
'mimeType' :'string' ,
'description' :'string' ,
'messageId' :'string' ,
'replyId' :'string' ,
'area' :'string' ,
'Content-Length' :null
};
fetch('http://localhost:10000/rooms/{roomId}/attachments' ,
{
method : 'POST' ,
body : inputBody,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const inputBody = string;
const headers = {
'Content-Type' :'application/octet-stream' ,
'Accept' :'application/json' ,
'fileName' :'string' ,
'mimeType' :'string' ,
'description' :'string' ,
'messageId' :'string' ,
'replyId' :'string' ,
'area' :'string' ,
'Content-Length' :null
};
fetch('http://localhost:10000/rooms/{roomId}/attachments' ,
{
method : 'POST' ,
body : JSON .stringify(inputBody),
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/octet-stream' ,
'Accept' => 'application/json' ,
'fileName' => 'string' ,
'mimeType' => 'string' ,
'description' => 'string' ,
'messageId' => 'string' ,
'replyId' => 'string' ,
'area' => 'string' ,
'Content-Length' => null
}
result = RestClient.post 'http://localhost:10000/rooms/{roomId}/attachments' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type' : 'application/octet-stream' ,
'Accept' : 'application/json' ,
'fileName' : 'string' ,
'mimeType' : 'string' ,
'description' : 'string' ,
'messageId' : 'string' ,
'replyId' : 'string' ,
'area' : 'string' ,
'Content-Length' : null
}
r = requests.post('http://localhost:10000/rooms/{roomId}/attachments' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/attachments" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Content-Type" : []string {"application/octet-stream" },
"Accept" : []string {"application/json" },
"fileName" : []string {"string" },
"mimeType" : []string {"string" },
"description" : []string {"string" },
"messageId" : []string {"string" },
"replyId" : []string {"string" },
"area" : []string {"string" },
"Content-Length" : []string {"null" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("POST" , "http://localhost:10000/rooms/{roomId}/attachments" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/octet-stream' ,
'Accept' => 'application/json' ,
'fileName' => 'string' ,
'mimeType' => 'string' ,
'description' => 'string' ,
'messageId' => 'string' ,
'replyId' => 'string' ,
'area' => 'string' ,
'Content-Length' => 'null' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('POST' ,'http://localhost:10000/rooms/{roomId}/attachments' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
POST /rooms/{roomId}/attachments
Insert an attachment
Body parameter
string
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
fileName
header
string
true
file name encoded to unicode
mimeType
header
string
true
content type
description
header
string
false
description encoded to unicode
messageId
header
string
false
description
replyId
header
string
false
identifier of the message being replied to
area
header
string
false
attachment's area
Content-Length
header
long
true
content length
body
body
string(binary)
true
file stream
Example responses
201 Response
{
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08"
}
Responses
Status
Meaning
Description
Schema
201
Created
File identifier
Id
413
Payload Too Large
The request had a payload that was too big
None
This operation does not require authentication
forwardMessages
Code samples
curl -X POST http://localhost:10000/rooms/{roomId}/forward \
-H 'Content-Type: application/json'
POST http://localhost:10000/rooms/{roomId}/forward HTTP/1.1
Host : localhost:10000
Content-Type : application/json
const inputBody = '[
{
"originalMessage": "string",
"originalMessageSentAt": "2019-08-24T14:15:22Z",
"description": "string"
}
]' ;
const headers = {
'Content-Type' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/forward' ,
{
method : 'POST' ,
body : inputBody,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const inputBody = [
{
"originalMessage" : "string" ,
"originalMessageSentAt" : "2019-08-24T14:15:22Z" ,
"description" : "string"
}
];
const headers = {
'Content-Type' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/forward' ,
{
method : 'POST' ,
body : JSON .stringify(inputBody),
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json'
}
result = RestClient.post 'http://localhost:10000/rooms/{roomId}/forward' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type' : 'application/json'
}
r = requests.post('http://localhost:10000/rooms/{roomId}/forward' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/forward" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Content-Type" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("POST" , "http://localhost:10000/rooms/{roomId}/forward" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('POST' ,'http://localhost:10000/rooms/{roomId}/forward' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
POST /rooms/{roomId}/forward
Message forwarding
Body parameter
[
{
"originalMessage" : "string" ,
"originalMessageSentAt" : "2019-08-24T14:15:22Z" ,
"description" : "string"
}
]
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
body
body
ForwardMessagesList
true
Messages forwarding request
Responses
Status
Meaning
Description
Schema
204
No Content
successfully forwarded the messages
None
401
Unauthorized
User not authorized
None
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
listRoomMember
Code samples
curl -X GET http://localhost:10000/rooms/{roomId}/members \
-H 'Accept: application/json'
GET http://localhost:10000/rooms/{roomId}/members HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/members' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/members' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get 'http://localhost:10000/rooms/{roomId}/members' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.get('http://localhost:10000/rooms/{roomId}/members' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/members" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/rooms/{roomId}/members" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/rooms/{roomId}/members' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /rooms/{roomId}/members
Retrieves every member to the given room
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
Example responses
200 Response
[
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
]
Responses
Status
Meaning
Description
Schema
200
OK
The room members list
Inline
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
Response Schema
Status Code 200
Name
Type
Required
Restrictions
Description
anonymous
[Member ]
false
none
[Information about a user's role in the room]
» userId
string(uuid)
true
none
user identifier
» owner
boolean
true
none
indicates whether it is the owner
This operation does not require authentication
deleteRoomMember
Code samples
curl -X DELETE http://localhost:10000/rooms/{roomId}/members/{userId}
DELETE http://localhost:10000/rooms/{roomId}/members/{userId} HTTP/1.1
Host : localhost:10000
fetch('http://localhost:10000/rooms/{roomId}/members/{userId}' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
fetch('http://localhost:10000/rooms/{roomId}/members/{userId}' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
result = RestClient.delete 'http://localhost:10000/rooms/{roomId}/members/{userId}' ,
params: {
}
p JSON.parse(result)
import requests
r = requests.delete('http://localhost:10000/rooms/{roomId}/members/{userId}' )
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/members/{userId}" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("DELETE" , "http://localhost:10000/rooms/{roomId}/members/{userId}" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
request('DELETE' ,'http://localhost:10000/rooms/{roomId}/members/{userId}' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
DELETE /rooms/{roomId}/members/{userId}
Removes a member from the room
Removes a member from the specified room. If the specified user is different from
the requester, this action is considered as a kick
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
userId
path
string(uuid)
true
user identifier
Responses
Status
Meaning
Description
Schema
204
No Content
The member was deleted correctly or it never existed
None
403
Forbidden
The requester could not access the resource
None
This operation does not require authentication
updateToOwner
Code samples
curl -X PUT http://localhost:10000/rooms/{roomId}/members/{userId}/owner
PUT http://localhost:10000/rooms/{roomId}/members/{userId}/owner HTTP/1.1
Host : localhost:10000
fetch('http://localhost:10000/rooms/{roomId}/members/{userId}/owner' ,
{
method : 'PUT'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
fetch('http://localhost:10000/rooms/{roomId}/members/{userId}/owner' ,
{
method : 'PUT'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
result = RestClient.put 'http://localhost:10000/rooms/{roomId}/members/{userId}/owner' ,
params: {
}
p JSON.parse(result)
import requests
r = requests.put('http://localhost:10000/rooms/{roomId}/members/{userId}/owner' )
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/members/{userId}/owner" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("PUT" , "http://localhost:10000/rooms/{roomId}/members/{userId}/owner" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
request('PUT' ,'http://localhost:10000/rooms/{roomId}/members/{userId}/owner' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
PUT /rooms/{roomId}/members/{userId}/owner
Promotes a member to owner
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
userId
path
string(uuid)
true
user identifier
Responses
Status
Meaning
Description
Schema
204
No Content
The member was promoted
None
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
deleteOwner
Code samples
curl -X DELETE http://localhost:10000/rooms/{roomId}/members/{userId}/owner
DELETE http://localhost:10000/rooms/{roomId}/members/{userId}/owner HTTP/1.1
Host : localhost:10000
fetch('http://localhost:10000/rooms/{roomId}/members/{userId}/owner' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
fetch('http://localhost:10000/rooms/{roomId}/members/{userId}/owner' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
result = RestClient.delete 'http://localhost:10000/rooms/{roomId}/members/{userId}/owner' ,
params: {
}
p JSON.parse(result)
import requests
r = requests.delete('http://localhost:10000/rooms/{roomId}/members/{userId}/owner' )
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/members/{userId}/owner" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("DELETE" , "http://localhost:10000/rooms/{roomId}/members/{userId}/owner" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
request('DELETE' ,'http://localhost:10000/rooms/{roomId}/members/{userId}/owner' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
DELETE /rooms/{roomId}/members/{userId}/owner
Demotes a member from owner to normal member
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
userId
path
string(uuid)
true
user identifier
Responses
Status
Meaning
Description
Schema
204
No Content
The member was demoted
None
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
getUsers
Code samples
curl -X GET http://localhost:10000/users?userIds=string \
-H 'Accept: application/json'
GET http://localhost:10000/users?userIds=string HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/users?userIds=string' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/users?userIds=string' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get 'http://localhost:10000/users' ,
params: {
'userIds' => 'array[string]'
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.get('http://localhost:10000/users' , params={
'userIds' : [
"string"
]
}, headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/users?userIds=string" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/users" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/users' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /users
Retrieves users
Parameters
Name
In
Type
Required
Description
userIds
query
array[string]
true
List of ids (max 10) of the users to retrieve
Example responses
200 Response
[
{
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"email" : "user@example.com" ,
"name" : "string" ,
"type" : "internal" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"statusMessage" : "string"
}
]
Responses
Status
Meaning
Description
Schema
200
OK
The requested users list
Inline
Response Schema
Status Code 200
Name
Type
Required
Restrictions
Description
anonymous
[User ]
false
none
[User data]
» id
string(uuid)
true
read-only
user's id
» email
string(email)
true
read-only
user's email
» name
string
true
read-only
user's name
» type
string
false
read-only
user type
» pictureUpdatedAt
string(date-time)
false
read-only
user profile picture update timestamp, returned only if the room picture was set at least once
» statusMessage
string
false
none
the user's status message
Enumerated Values
Property
Value
type
internal
type
guest
This operation does not require authentication
getCapabilities
Code samples
curl -X GET http://localhost:10000/users/capabilities \
-H 'Accept: application/json'
GET http://localhost:10000/users/capabilities HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/users/capabilities' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/users/capabilities' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get 'http://localhost:10000/users/capabilities' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.get('http://localhost:10000/users/capabilities' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/users/capabilities" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/users/capabilities" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/users/capabilities' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /users/capabilities
Retrieve current user capabilities
Example responses
200 Response
{
"canSeeMessageReads" : true ,
"canSeeUsersPresence" : true ,
"canVideoCall" : true ,
"canVideoCallRecord" : true ,
"canUseVirtualBackground" : true ,
"editMessageTimeLimitInMinutes" : 0 ,
"deleteMessageTimeLimitInMinutes" : 0 ,
"maxGroupMembers" : 0 ,
"maxRoomImageSizeInKb" : 0 ,
"maxUserImageSizeInKb" : 0
}
Responses
This operation does not require authentication
getUser
Code samples
curl -X GET http://localhost:10000/users/{userId} \
-H 'Accept: application/json'
GET http://localhost:10000/users/{userId} HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/users/{userId}' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/users/{userId}' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get 'http://localhost:10000/users/{userId}' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.get('http://localhost:10000/users/{userId}' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/users/{userId}" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/users/{userId}" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/users/{userId}' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /users/{userId}
Retrieves a user
Parameters
Name
In
Type
Required
Description
userId
path
string(uuid)
true
user identifier
Example responses
200 Response
{
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"email" : "user@example.com" ,
"name" : "string" ,
"type" : "internal" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"statusMessage" : "string"
}
Responses
Status
Meaning
Description
Schema
200
OK
Requested user
User
404
Not Found
The requested resource was not found
None
This operation does not require authentication
getUserPicture
Code samples
curl -X GET http://localhost:10000/users/{userId}/picture \
-H 'Accept: application/octet-stream'
GET http://localhost:10000/users/{userId}/picture HTTP/1.1
Host : localhost:10000
Accept : application/octet-stream
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/users/{userId}/picture' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/users/{userId}/picture' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/octet-stream'
}
result = RestClient.get 'http://localhost:10000/users/{userId}/picture' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/octet-stream'
}
r = requests.get('http://localhost:10000/users/{userId}/picture' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/users/{userId}/picture" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/octet-stream" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/users/{userId}/picture" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/octet-stream' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/users/{userId}/picture' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /users/{userId}/picture
Retrieves the user picture
Parameters
Name
In
Type
Required
Description
userId
path
string(uuid)
true
user identifier
Example responses
200 Response
Responses
Status
Meaning
Description
Schema
200
OK
The requested picture
string
401
Unauthorized
User not authorized
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
updateUserPicture
Code samples
curl -X PUT http://localhost:10000/users/{userId}/picture \
-H 'Content-Type: application/octet-stream' \
-H 'fileName: string' \
-H 'mimeType: string' \
-H 'Content-Length: null'
PUT http://localhost:10000/users/{userId}/picture HTTP/1.1
Host : localhost:10000
Content-Type : application/octet-stream
fileName: string
mimeType: string
Content-Length: null
const inputBody = 'string' ;
const headers = {
'Content-Type' :'application/octet-stream' ,
'fileName' :'string' ,
'mimeType' :'string' ,
'Content-Length' :null
};
fetch('http://localhost:10000/users/{userId}/picture' ,
{
method : 'PUT' ,
body : inputBody,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const inputBody = string;
const headers = {
'Content-Type' :'application/octet-stream' ,
'fileName' :'string' ,
'mimeType' :'string' ,
'Content-Length' :null
};
fetch('http://localhost:10000/users/{userId}/picture' ,
{
method : 'PUT' ,
body : JSON .stringify(inputBody),
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/octet-stream' ,
'fileName' => 'string' ,
'mimeType' => 'string' ,
'Content-Length' => null
}
result = RestClient.put 'http://localhost:10000/users/{userId}/picture' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type' : 'application/octet-stream' ,
'fileName' : 'string' ,
'mimeType' : 'string' ,
'Content-Length' : null
}
r = requests.put('http://localhost:10000/users/{userId}/picture' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/users/{userId}/picture" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Content-Type" : []string {"application/octet-stream" },
"fileName" : []string {"string" },
"mimeType" : []string {"string" },
"Content-Length" : []string {"null" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("PUT" , "http://localhost:10000/users/{userId}/picture" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/octet-stream' ,
'fileName' => 'string' ,
'mimeType' => 'string' ,
'Content-Length' => 'null' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('PUT' ,'http://localhost:10000/users/{userId}/picture' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
PUT /users/{userId}/picture
Uploads and sets a new user picture
Body parameter
string
Parameters
Name
In
Type
Required
Description
userId
path
string(uuid)
true
user identifier
fileName
header
string
true
file name encoded to unicode
mimeType
header
string
true
content type
Content-Length
header
long
true
content length
body
body
string(binary)
true
image to set
Responses
Status
Meaning
Description
Schema
204
No Content
User picture was changed correctly
None
400
Bad Request
The request had wrong or missing parameters
None
401
Unauthorized
User not authorized
None
403
Forbidden
The requester could not access the resource
None
This operation does not require authentication
deleteUserPicture
Code samples
curl -X DELETE http://localhost:10000/users/{userId}/picture
DELETE http://localhost:10000/users/{userId}/picture HTTP/1.1
Host : localhost:10000
fetch('http://localhost:10000/users/{userId}/picture' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
fetch('http://localhost:10000/users/{userId}/picture' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
result = RestClient.delete 'http://localhost:10000/users/{userId}/picture' ,
params: {
}
p JSON.parse(result)
import requests
r = requests.delete('http://localhost:10000/users/{userId}/picture' )
print (r.json())
URL obj = new URL("http://localhost:10000/users/{userId}/picture" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("DELETE" , "http://localhost:10000/users/{userId}/picture" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
request('DELETE' ,'http://localhost:10000/users/{userId}/picture' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
DELETE /users/{userId}/picture
Delete the user picture
Parameters
Name
In
Type
Required
Description
userId
path
string(uuid)
true
user identifier
Responses
Status
Meaning
Description
Schema
204
No Content
User picture was deleted correctly
None
401
Unauthorized
User not authorized
None
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
deleteAttachment
Code samples
curl -X DELETE http://localhost:10000/attachments/{fileId}
DELETE http://localhost:10000/attachments/{fileId} HTTP/1.1
Host : localhost:10000
fetch('http://localhost:10000/attachments/{fileId}' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
fetch('http://localhost:10000/attachments/{fileId}' ,
{
method : 'DELETE'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
result = RestClient.delete 'http://localhost:10000/attachments/{fileId}' ,
params: {
}
p JSON.parse(result)
import requests
r = requests.delete('http://localhost:10000/attachments/{fileId}' )
print (r.json())
URL obj = new URL("http://localhost:10000/attachments/{fileId}" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("DELETE" , "http://localhost:10000/attachments/{fileId}" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
request('DELETE' ,'http://localhost:10000/attachments/{fileId}' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
DELETE /attachments/{fileId}
Deletes an uploaded attachment
Parameters
Name
In
Type
Required
Description
fileId
path
string(uuid)
true
file identifier
Responses
Status
Meaning
Description
Schema
204
No Content
The file was deleted correctly
None
403
Forbidden
The requester could not access the resource
None
This operation does not require authentication
getAttachmentInfo
Code samples
curl -X GET http://localhost:10000/attachments/{fileId} \
-H 'Accept: application/json'
GET http://localhost:10000/attachments/{fileId} HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/attachments/{fileId}' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/attachments/{fileId}' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get 'http://localhost:10000/attachments/{fileId}' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.get('http://localhost:10000/attachments/{fileId}' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/attachments/{fileId}" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/attachments/{fileId}" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/attachments/{fileId}' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /attachments/{fileId}
Retrieves info related to an uploaded attachment
Parameters
Name
In
Type
Required
Description
fileId
path
string(uuid)
true
file identifier
Example responses
200 Response
{
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"name" : "string" ,
"size" : 0 ,
"mimeType" : "string" ,
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"roomId" : "c3631f02-ff67-42b8-8775-18c47f52a678" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"area" : "string"
}
Responses
Status
Meaning
Description
Schema
200
OK
Attachment informations
Attachment
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
getAttachment
Code samples
curl -X GET http://localhost:10000/attachments/{fileId}/download \
-H 'Accept: application/octet-stream'
GET http://localhost:10000/attachments/{fileId}/download HTTP/1.1
Host : localhost:10000
Accept : application/octet-stream
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/attachments/{fileId}/download' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/attachments/{fileId}/download' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/octet-stream'
}
result = RestClient.get 'http://localhost:10000/attachments/{fileId}/download' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/octet-stream'
}
r = requests.get('http://localhost:10000/attachments/{fileId}/download' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/attachments/{fileId}/download" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/octet-stream" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/attachments/{fileId}/download" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/octet-stream' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/attachments/{fileId}/download' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /attachments/{fileId}/download
Retrieves an uploaded attachment
Parameters
Name
In
Type
Required
Description
fileId
path
string(uuid)
true
file identifier
Example responses
200 Response
Responses
Status
Meaning
Description
Schema
200
OK
The requested file
string
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
getHealthStatus
Code samples
curl -X GET http://localhost:10000/health \
-H 'Accept: application/json'
GET http://localhost:10000/health HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/health' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/health' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get 'http://localhost:10000/health' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.get('http://localhost:10000/health' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/health" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/health" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/health' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /health
Returns the general service status
Example responses
200 Response
{
"isLive" : true ,
"status" : "ok" ,
"dependencies" : [
{
"name" : "database" ,
"isHealthy" : true
}
]
}
Responses
Status
Meaning
Description
Schema
200
OK
General status of the service and its dependencies
HealthStatus
This operation does not require authentication
isLive
Code samples
curl -X GET http://localhost:10000/health/live
GET http://localhost:10000/health/live HTTP/1.1
Host : localhost:10000
fetch('http://localhost:10000/health/live' ,
{
method : 'GET'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
fetch('http://localhost:10000/health/live' ,
{
method : 'GET'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
result = RestClient.get 'http://localhost:10000/health/live' ,
params: {
}
p JSON.parse(result)
import requests
r = requests.get('http://localhost:10000/health/live' )
print (r.json())
URL obj = new URL("http://localhost:10000/health/live" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/health/live" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
request('GET' ,'http://localhost:10000/health/live' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /health/live
Returns 204 if the service is alive
Responses
Status
Meaning
Description
Schema
204
No Content
The service is alive
None
This operation does not require authentication
isReady
Code samples
curl -X GET http://localhost:10000/health/ready
GET http://localhost:10000/health/ready HTTP/1.1
Host : localhost:10000
fetch('http://localhost:10000/health/ready' ,
{
method : 'GET'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
fetch('http://localhost:10000/health/ready' ,
{
method : 'GET'
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
result = RestClient.get 'http://localhost:10000/health/ready' ,
params: {
}
p JSON.parse(result)
import requests
r = requests.get('http://localhost:10000/health/ready' )
print (r.json())
URL obj = new URL("http://localhost:10000/health/ready" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/health/ready" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
request('GET' ,'http://localhost:10000/health/ready' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /health/ready
Returns 204 if the service is ready to receive requests
Responses
Status
Meaning
Description
Schema
204
No Content
The service is ready to receive requests
None
429
Too Many Requests
The service is ready but some non-fundamental dependencies are not reachable
None
500
Internal Server Error
The service is not yet ready to receive requests
None
This operation does not require authentication
getTokens
Code samples
curl -X GET http://localhost:10000/auth/token \
-H 'Accept: application/json'
GET http://localhost:10000/auth/token HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/auth/token' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/auth/token' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get 'http://localhost:10000/auth/token' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.get('http://localhost:10000/auth/token' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/auth/token" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/auth/token" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/auth/token' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /auth/token
Retrives the authenticated tokens
Example responses
200 Response
{
"zmToken" : "string"
}
Responses
Status
Meaning
Description
Schema
200
OK
The authenticated tokens.
Token
401
Unauthorized
User not authorized
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
getMeetingByRoomId
Code samples
curl -X GET http://localhost:10000/rooms/{roomId}/meeting \
-H 'Accept: application/json'
GET http://localhost:10000/rooms/{roomId}/meeting HTTP/1.1
Host : localhost:10000
Accept : application/json
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/meeting' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/json'
};
fetch('http://localhost:10000/rooms/{roomId}/meeting' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json'
}
result = RestClient.get 'http://localhost:10000/rooms/{roomId}/meeting' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/json'
}
r = requests.get('http://localhost:10000/rooms/{roomId}/meeting' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/rooms/{roomId}/meeting" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/json" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/rooms/{roomId}/meeting" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/json' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/rooms/{roomId}/meeting' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /rooms/{roomId}/meeting
Retrieves the meeting associated with the requested room
Parameters
Name
In
Type
Required
Description
roomId
path
string(uuid)
true
room identifier
Example responses
Responses
Status
Meaning
Description
Schema
200
OK
Gets the requested meeting data
None
401
Unauthorized
User not authorized
None
403
Forbidden
The requester could not access the resource
None
404
Not Found
The requested resource was not found
None
Response Schema
This operation does not require authentication
getImagePreview
Code samples
curl -X GET http://localhost:10000/preview/image/{fileId}/{area}/ \
-H 'Accept: application/octet-stream'
GET http://localhost:10000/preview/image/{fileId}/{area}/ HTTP/1.1
Host : localhost:10000
Accept : application/octet-stream
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/preview/image/{fileId}/{area}/' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/preview/image/{fileId}/{area}/' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/octet-stream'
}
result = RestClient.get 'http://localhost:10000/preview/image/{fileId}/{area}/' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/octet-stream'
}
r = requests.get('http://localhost:10000/preview/image/{fileId}/{area}/' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/preview/image/{fileId}/{area}/" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/octet-stream" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/preview/image/{fileId}/{area}/" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/octet-stream' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/preview/image/{fileId}/{area}/' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /preview/image/{fileId}/{area}/
Get image preview
Creates and returns a preview of the image fetched by id
with the given size, quality and format
fileId : UUID of the image
quality : quality of the output image
(the higher you go the slower the process)
output_format : format of the output image
area : width of the output image (>=0) x
height of the output image (>=0), width x height => 100x200.
The first is width, the latter height, the order is important!
crop : True will crop the picture starting from the borders.
This option will lose information, leaving it False will scale and
have borders to fill the requested size.
Parameters
Name
In
Type
Required
Description
fileId
path
string(uuid)
true
file identifier
area
path
string
true
none
quality
query
ImageQualityEnum
false
none
output_format
query
any
false
none
crop
query
boolean
false
none
Enumerated Values
Parameter
Value
quality
Lowest
quality
Low
quality
Medium
quality
High
quality
Highest
Example responses
200 Response
Responses
Status
Meaning
Description
Schema
200
OK
The preview of the requested file
string
400
Bad Request
The request had wrong or missing parameters
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
getImageThumbnail
Code samples
curl -X GET http://localhost:10000/preview/image/{fileId}/{area}/thumbnail \
-H 'Accept: application/octet-stream'
GET http://localhost:10000/preview/image/{fileId}/{area}/thumbnail HTTP/1.1
Host : localhost:10000
Accept : application/octet-stream
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/preview/image/{fileId}/{area}/thumbnail' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/preview/image/{fileId}/{area}/thumbnail' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/octet-stream'
}
result = RestClient.get 'http://localhost:10000/preview/image/{fileId}/{area}/thumbnail' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/octet-stream'
}
r = requests.get('http://localhost:10000/preview/image/{fileId}/{area}/thumbnail' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/preview/image/{fileId}/{area}/thumbnail" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/octet-stream" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/preview/image/{fileId}/{area}/thumbnail" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/octet-stream' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/preview/image/{fileId}/{area}/thumbnail' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /preview/image/{fileId}/{area}/thumbnail
Get image thumbnail
Creates and returns a preview of the image fetched by id
with the given size, quality and format
fileId : UUID of the image
quality : quality of the output image
(the higher you go the slower the process)
output_format : format of the output image
area : width of the output image (>=0) x
height of the output image (>=0), width x height => 100x200.
The first is width, the latter height, the order is important!
shape : Rounded and Rectangular are currently supported.
Parameters
Name
In
Type
Required
Description
fileId
path
string(uuid)
true
file identifier
area
path
string
true
none
quality
query
ImageQualityEnum
false
none
output_format
query
any
false
none
shape
query
any
false
none
Enumerated Values
Parameter
Value
quality
Lowest
quality
Low
quality
Medium
quality
High
quality
Highest
Example responses
200 Response
Responses
Status
Meaning
Description
Schema
200
OK
The preview of the requested file
string
400
Bad Request
The request had wrong or missing parameters
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
getPdfPreview
Code samples
curl -X GET http://localhost:10000/preview/pdf/{fileId}/ \
-H 'Accept: application/octet-stream'
GET http://localhost:10000/preview/pdf/{fileId}/ HTTP/1.1
Host : localhost:10000
Accept : application/octet-stream
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/preview/pdf/{fileId}/' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/preview/pdf/{fileId}/' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/octet-stream'
}
result = RestClient.get 'http://localhost:10000/preview/pdf/{fileId}/' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/octet-stream'
}
r = requests.get('http://localhost:10000/preview/pdf/{fileId}/' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/preview/pdf/{fileId}/" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/octet-stream" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/preview/pdf/{fileId}/" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/octet-stream' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/preview/pdf/{fileId}/' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /preview/pdf/{fileId}/
Get pdf preview
Creates and returns a preview of the pdf fetched by id,
the pdf file will contain the first and last page given. With default values
it will return a pdf with all the pages.
fileId : UUID of the pdf
first_page : integer value of first page to preview (n>=1)
last_page : integer value of last page to preview (0 = last of the original pdf)
Parameters
Name
In
Type
Required
Description
fileId
path
string(uuid)
true
file identifier
firstPage
query
integer
false
none
lastPage
query
integer
false
none
Example responses
200 Response
Responses
Status
Meaning
Description
Schema
200
OK
The preview of the requested file
string
400
Bad Request
The request had wrong or missing parameters
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
getPdfThumbnail
Code samples
curl -X GET http://localhost:10000/preview/pdf/{fileId}/{area}/thumbnail \
-H 'Accept: application/octet-stream'
GET http://localhost:10000/preview/pdf/{fileId}/{area}/thumbnail HTTP/1.1
Host : localhost:10000
Accept : application/octet-stream
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/preview/pdf/{fileId}/{area}/thumbnail' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
const fetch = require ('node-fetch' );
const headers = {
'Accept' :'application/octet-stream'
};
fetch('http://localhost:10000/preview/pdf/{fileId}/{area}/thumbnail' ,
{
method : 'GET' ,
headers : headers
})
.then(function (res ) {
return res.json();
}).then(function (body ) {
console .log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/octet-stream'
}
result = RestClient.get 'http://localhost:10000/preview/pdf/{fileId}/{area}/thumbnail' ,
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept' : 'application/octet-stream'
}
r = requests.get('http://localhost:10000/preview/pdf/{fileId}/{area}/thumbnail' , headers = headers)
print (r.json())
URL obj = new URL("http://localhost:10000/preview/pdf/{fileId}/{area}/thumbnail" );
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET" );
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null ) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main () {
headers := map [string ][]string {
"Accept" : []string {"application/octet-stream" },
}
data := bytes.NewBuffer([]byte {jsonReq})
req, err := http.NewRequest("GET" , "http://localhost:10000/preview/pdf/{fileId}/{area}/thumbnail" , data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
}
'application/octet-stream' ,
);
$client = new \GuzzleHttp\Client();
$request_body = array ();
try {
$response = $client ->request('GET' ,'http://localhost:10000/preview/pdf/{fileId}/{area}/thumbnail' , array (
'headers' => $headers ,
'json' => $request_body ,
)
);
print_r($response ->getBody()->getContents());
}
catch (\GuzzleHttp\Exception \BadResponseException $e ) {
print_r($e ->getMessage());
}
GET /preview/pdf/{fileId}/{area}/thumbnail
Get pdf thumbnail
Creates and returns a preview of the pdf fetched by id
with the given size, quality and format
fileId : UUID of the pdf
quality : quality of the output image
(the higher you go the slower the process)
output_format : format of the output image
area : width of the output image (>=0) x
height of the output image (>=0), width x height => 100x200.
The first is width, the latter height, the order is important!
shape : Rounded and Rectangular are currently supported.
Parameters
Name
In
Type
Required
Description
fileId
path
string(uuid)
true
file identifier
area
path
string
true
none
quality
query
ImageQualityEnum
false
none
output_format
query
any
false
none
shape
query
any
false
none
Enumerated Values
Parameter
Value
quality
Lowest
quality
Low
quality
Medium
quality
High
quality
Highest
Example responses
200 Response
Responses
Status
Meaning
Description
Schema
200
OK
The preview of the requested file
string
400
Bad Request
The request had wrong or missing parameters
None
404
Not Found
The requested resource was not found
None
This operation does not require authentication
Schemas
Error
{
"traceId" : "string" ,
"message" : "string"
}
Error object returned from requests with developer mode active
Properties
Name
Type
Required
Restrictions
Description
traceId
string
false
read-only
random hash used to identify the error within logs
message
string
false
read-only
a message describing the error
HealthStatus
{
"isLive" : true ,
"status" : "ok" ,
"dependencies" : [
{
"name" : "database" ,
"isHealthy" : true
}
]
}
Health status of the service and its dependencies
Properties
Name
Type
Required
Restrictions
Description
isLive
boolean
false
read-only
describes if the service is alive
status
HealthStatusType
false
none
Health status types
dependencies
[DependencyHealth ]
false
none
health of this service dependencies
HealthStatusType
"ok"
Health status types
Properties
Name
Type
Required
Restrictions
Description
anonymous
string
false
none
Health status types
Enumerated Values
Property
Value
anonymous
ok
anonymous
warn
anonymous
error
DependencyHealth
{
"name" : "database" ,
"isHealthy" : true
}
Health status of a service dependency
Properties
Name
Type
Required
Restrictions
Description
name
DependencyHealthType
false
none
Health dependency types
isHealthy
boolean
false
read-only
whether the dependency is available and operative
DependencyHealthType
"database"
Health dependency types
Properties
Name
Type
Required
Restrictions
Description
anonymous
string
false
none
Health dependency types
Enumerated Values
Property
Value
anonymous
database
anonymous
xmpp_server
anonymous
event_dispatcher
anonymous
storage_service
anonymous
previewer_service
anonymous
authentication_service
anonymous
profiling_service
anonymous
videoserver_service
Id
{
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08"
}
Identifier object
Properties
Name
Type
Required
Restrictions
Description
id
string(uuid)
true
read-only
identifier
ClearedDate
{
"clearedAt" : "2019-08-24T14:15:22Z"
}
Properties
Name
Type
Required
Restrictions
Description
clearedAt
string(date-time)
true
read-only
date since messages were cleared
Capabilities
{
"canSeeMessageReads" : true ,
"canSeeUsersPresence" : true ,
"canVideoCall" : true ,
"canVideoCallRecord" : true ,
"canUseVirtualBackground" : true ,
"editMessageTimeLimitInMinutes" : 0 ,
"deleteMessageTimeLimitInMinutes" : 0 ,
"maxGroupMembers" : 0 ,
"maxRoomImageSizeInKb" : 0 ,
"maxUserImageSizeInKb" : 0
}
Properties
Name
Type
Required
Restrictions
Description
canSeeMessageReads
boolean
true
none
indicates whether it can see if the messages have been read
canSeeUsersPresence
boolean
true
none
indicates whether it can see the presence of the other users
canVideoCall
boolean
true
none
indicates whether it can access video calls
canVideoCallRecord
boolean
true
none
indicates whether it can record video calls
canUseVirtualBackground
boolean
true
none
indicates whether it can use a virtual background
editMessageTimeLimitInMinutes
integer
true
none
limit of minutes within which a message can be edited
deleteMessageTimeLimitInMinutes
integer
true
none
limit of minutes within which a message can be deleted
maxGroupMembers
integer
true
none
maximum number of users who can be members of a group
maxRoomImageSizeInKb
integer
true
none
maximum size for a room image in kB
maxUserImageSizeInKb
integer
true
none
maximum size for a user image in kB
User
{
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"email" : "user@example.com" ,
"name" : "string" ,
"type" : "internal" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"statusMessage" : "string"
}
User data
Properties
Name
Type
Required
Restrictions
Description
id
string(uuid)
true
read-only
user's id
email
string(email)
true
read-only
user's email
name
string
true
read-only
user's name
type
string
false
read-only
user type
pictureUpdatedAt
string(date-time)
false
read-only
user profile picture update timestamp, returned only if the room picture was set at least once
statusMessage
string
false
none
the user's status message
Enumerated Values
Property
Value
type
internal
type
guest
RoomType
"group"
Managed room types
Properties
Name
Type
Required
Restrictions
Description
anonymous
string
false
none
Managed room types
Enumerated Values
Property
Value
anonymous
group
anonymous
one_to_one
anonymous
workspace
anonymous
channel
anonymous
temporary
RoomEditableFields
{
"name" : "string" ,
"description" : "string"
}
Room fields that can be updated
Properties
Name
Type
Required
Restrictions
Description
name
string
false
none
room name
description
string
false
none
room description
RoomCreationFields
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43"
}
Room fields for its creation
Properties
Name
Type
Required
Restrictions
Description
membersIds
[string]
false
none
members identifiers list to be subscribed to the room
allOf
Name
Type
Required
Restrictions
Description
anonymous
RoomEditableFields
false
none
Room fields that can be updated
and
Name
Type
Required
Restrictions
Description
anonymous
object
false
none
none
» type
RoomType
false
none
Managed room types
» parentId
string(uuid)
false
none
identifier of the referenced workspace
Room
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43" ,
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"rank" : 0 ,
"meetingId" : "bba231d0-d474-4cf9-bb49-b12d0cb2a3ed" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"updatedAt" : "2019-08-24T14:15:22Z" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"children" : [
{
"membersIds" : [
"497f6eca-6276-4993-bfeb-53cbbbba6f08"
],
"name" : "string" ,
"description" : "string" ,
"type" : "group" ,
"parentId" : "70850378-7d3c-4f45-91b7-942d4dfbbd43" ,
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"rank" : 0 ,
"meetingId" : "bba231d0-d474-4cf9-bb49-b12d0cb2a3ed" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"updatedAt" : "2019-08-24T14:15:22Z" ,
"pictureUpdatedAt" : "2019-08-24T14:15:22Z" ,
"children" : [],
"members" : [
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
],
"userSettings" : {
"muted" : true ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
}
],
"members" : [
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
],
"userSettings" : {
"muted" : true ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
}
Room data
Properties
allOf
Name
Type
Required
Restrictions
Description
anonymous
RoomCreationFields
false
none
Room fields for its creation
and
Name
Type
Required
Restrictions
Description
anonymous
object
false
none
none
» id
string(uuid)
false
read-only
room identifier
» rank
integer
false
read-only
number that defines the sorting position for workspaces room
» meetingId
string(uuid)
false
read-only
identifier of associated meeting
» createdAt
string(date-time)
false
read-only
entity creation date
» updatedAt
string(date-time)
false
read-only
entity update date
» pictureUpdatedAt
string(date-time)
false
read-only
room profile picture update timestamp, returned only if the room picture was set at least once
» children
[Room ]
false
none
[Room data]
» members
[Member ]
false
none
list of users subscribed to the room
» userSettings
RoomUserSettings
false
none
Preferences that an user has set for a room
RoomRank
{
"roomId" : "c3631f02-ff67-42b8-8775-18c47f52a678" ,
"rank" : 0
}
object which defines a room rank
Properties
Name
Type
Required
Restrictions
Description
roomId
string(uuid)
true
none
room identifier
rank
integer
true
none
room position
RoomRanks
[
{
"roomId" : "c3631f02-ff67-42b8-8775-18c47f52a678" ,
"rank" : 0
}
]
rank room list
Properties
Name
Type
Required
Restrictions
Description
anonymous
[RoomRank ]
false
none
rank room list
RoomUserSettings
{
"muted" : true ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
Preferences that an user has set for a room
Properties
Name
Type
Required
Restrictions
Description
muted
boolean
true
none
indicates whether the user has muted
clearedAt
string(date-time)
true
none
room clear history date, returned only if the room clear history has been cleared at least once
"members"
Room extra fields
Properties
Name
Type
Required
Restrictions
Description
anonymous
string
false
none
Room extra fields
Enumerated Values
Property
Value
anonymous
members
anonymous
settings
Member
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false
}
Information about a user's role in the room
Properties
Name
Type
Required
Restrictions
Description
userId
string(uuid)
true
none
user identifier
owner
boolean
true
none
indicates whether it is the owner
MemberToInsert
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false ,
"historyCleared" : true
}
Information about the member to insert in the room
Properties
allOf
Name
Type
Required
Restrictions
Description
anonymous
Member
false
none
Information about a user's role in the room
and
Name
Type
Required
Restrictions
Description
anonymous
object
false
none
none
» historyCleared
boolean
true
none
indicates whether it can see previous messages, after it has been added to the room
MemberInserted
{
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"owner" : false ,
"clearedAt" : "2019-08-24T14:15:22Z"
}
Information about the member to inserted in the room
Properties
allOf
Name
Type
Required
Restrictions
Description
anonymous
Member
false
none
Information about a user's role in the room
and
Name
Type
Required
Restrictions
Description
anonymous
object
false
none
none
» clearedAt
string(date-time)
true
none
room clear history timestamp, returned only if the room history has been cleared at least once
Attachment
{
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"name" : "string" ,
"size" : 0 ,
"mimeType" : "string" ,
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"roomId" : "c3631f02-ff67-42b8-8775-18c47f52a678" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"area" : "string"
}
Attachment of a message
Properties
Name
Type
Required
Restrictions
Description
id
string(uuid)
true
read-only
identifier
name
string
true
none
file name
size
integer(int64)
true
read-only
file length
mimeType
string
true
read-only
mime type
userId
string(uuid)
true
read-only
identifier of updated user
roomId
string(uuid)
true
read-only
identifier of destination room
createdAt
string(date-time)
false
read-only
creation date
area
string
false
read-only
attachment's area
{
"filter" : "string" ,
"attachments" : [
{
"id" : "497f6eca-6276-4993-bfeb-53cbbbba6f08" ,
"name" : "string" ,
"size" : 0 ,
"mimeType" : "string" ,
"userId" : "2c4a230c-5085-4924-a3e1-25fb4fc5965b" ,
"roomId" : "c3631f02-ff67-42b8-8775-18c47f52a678" ,
"createdAt" : "2019-08-24T14:15:22Z" ,
"area" : "string"
}
]
}
Attachment pagination
Properties
Name
Type
Required
Restrictions
Description
filter
string
false
none
filter for the next page
attachments
[Attachment ]
false
none
paged list of attachments metadata
Token
{
"zmToken" : "string"
}
authenticated tokens
Properties
Name
Type
Required
Restrictions
Description
zmToken
string
false
none
ZM token
ImageQualityEnum
"Lowest"
ImageQualityEnum
Properties
Name
Type
Required
Restrictions
Description
ImageQualityEnum
string
false
none
Class representing all the image quality accepted values
Enumerated Values
Property
Value
ImageQualityEnum
Lowest
ImageQualityEnum
Low
ImageQualityEnum
Medium
ImageQualityEnum
High
ImageQualityEnum
Highest
ImageTypeEnum
"Jpeg"
ImageTypeEnum
Properties
Name
Type
Required
Restrictions
Description
ImageTypeEnum
string
false
none
Class representing all the image type accepted values
Enumerated Values
Property
Value
ImageTypeEnum
Jpeg
ImageTypeEnum
Png
ImageTypeEnum
Gif
ImageShapeEnum
"Rounded"
ImageShapeEnum
Properties
Name
Type
Required
Restrictions
Description
ImageShapeEnum
string
false
none
Class representing all the image shape accepted values
Enumerated Values
Property
Value
ImageShapeEnum
Rounded
ImageShapeEnum
Rectangular
ForwardMessagesList
[
{
"originalMessage" : "string" ,
"originalMessageSentAt" : "2019-08-24T14:15:22Z" ,
"description" : "string"
}
]
Room data
Properties
Name
Type
Required
Restrictions
Description
anonymous
[ForwardMessage ]
false
none
Room data
ForwardMessage
{
"originalMessage" : "string" ,
"originalMessageSentAt" : "2019-08-24T14:15:22Z" ,
"description" : "string"
}
Message to forward
Properties
Name
Type
Required
Restrictions
Description
originalMessage
string
true
none
XML message to forward
originalMessageSentAt
string(date-time)
false
none
date and time the original message was sent
description
string
false
none
description of the forwarded message