WolkAbout IoT Platform API Administration, User And Role Management v21.GA

WolkAbout IoT Platform API is a RESTful API used for manipulating and managing WolkAbout platform resources. In order to use the API, client has to be ableto send HTTP requests and work with JSON data.

Base URLs:

https://api-demo.wolkabout.com

Email: Wolkabout Web: Wolkabout

Authentication

API Key (Bearer)
- Parameter Name: Authorization, in: header.

audit-log-api

pageUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/auditLog \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/auditLog HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/auditLog',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/auditLog',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/auditLog',
  params: {
  'from' => 'undefined',
'to' => 'undefined'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/auditLog', params={
  'from': undefined,  'to': undefined
}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/auditLog");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/auditLog", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/auditLog

page

Permissions:
isAuthenticated()

Description:
Retrieve pages of audit log.
sort - (optional, defaults to timestamp,desc) timestamp,asc or timestamp,desc
from - (required) filter logs after this timestamp
to - (required) filter logs before this timestamp
query (optional) - search query string. It is possible to use advanced and regex search. For more details see:
https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-query-string-query.html

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query
from	query	undefined	true	from
to	query	undefined	true	to

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

brand-api

deleteBrandUsingDELETE

# You can also use wget
curl -X DELETE https://api-demo.wolkabout.com/api/brands \
  -H 'Authorization: API_KEY'

DELETE https://api-demo.wolkabout.com/api/brands HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/brands',
  method: 'DELETE',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/brands',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.DELETE 'https://api-demo.wolkabout.com/api/brands',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.DELETE('https://api-demo.wolkabout.com/api/brands', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/brands");
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() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-demo.wolkabout.com/api/brands", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/brands

deleteBrand

Permissions:
isAuthenticated()

Description:
Deletes brand.

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

createUsingPOST

# You can also use wget
curl -X POST https://api-demo.wolkabout.com/api/brands \
  -H 'Authorization: API_KEY'

POST https://api-demo.wolkabout.com/api/brands HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/brands',
  method: 'POST',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/brands',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST 'https://api-demo.wolkabout.com/api/brands',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST('https://api-demo.wolkabout.com/api/brands', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/brands");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-demo.wolkabout.com/api/brands", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/brands

create

Permissions:
isAuthenticated()

Description:
Creates new brand.

Parameters

Parameter	In	Type	Required	Description
brand	body	Brand	true	brand

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

readUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/brands \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/brands HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/brands',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/brands',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/brands',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/brands', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/brands");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/brands", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/brands

read

Permissions:
isAuthenticated()

Description:
Returns information of the brand.

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/brands \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/brands HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/brands',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/brands',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/brands',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/brands', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/brands");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/brands", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/brands

update

Permissions:
isAuthenticated()

Description:
Updates brand.

Parameters

Parameter	In	Type	Required	Description
brand	body	Brand	true	brand

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

conversion-api

validateUsingPOST

# You can also use wget
curl -X POST https://api-demo.wolkabout.com/api/conversions/validate \
  -H 'Authorization: API_KEY'

POST https://api-demo.wolkabout.com/api/conversions/validate HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/conversions/validate',
  method: 'POST',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/conversions/validate',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST 'https://api-demo.wolkabout.com/api/conversions/validate',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST('https://api-demo.wolkabout.com/api/conversions/validate', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/conversions/validate");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-demo.wolkabout.com/api/conversions/validate", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/conversions/validate

validate

Permissions:
isAuthenticated()

Description:
Validates conversion formula.

Parameters

Parameter	In	Type	Required	Description
dto	body	ConversionValidateDto	true	dto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

bulkDeleteUsingDELETE

# You can also use wget
curl -X DELETE https://api-demo.wolkabout.com/api/conversions \
  -H 'Authorization: API_KEY'

DELETE https://api-demo.wolkabout.com/api/conversions HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/conversions',
  method: 'DELETE',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/conversions',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.DELETE 'https://api-demo.wolkabout.com/api/conversions',
  params: {
  'ids' => 'undefined'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.DELETE('https://api-demo.wolkabout.com/api/conversions', params={
  'ids': undefined
}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/conversions");
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() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-demo.wolkabout.com/api/conversions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/conversions

bulkDelete

Permissions:
isAuthenticated()

Description:
Deletes multiple conversions based on ids.

Parameters

Parameter	In	Type	Required	Description
ids	query	undefined	true	ids

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

listSimpleUsingGET

# You can also use wget
curl -X GET (PRODUCES: APPLICATION/VND.CONVERSION.SIMPLE+JSON) https://api-demo.wolkabout.com/api/conversions \
  -H 'Authorization: API_KEY'

GET (PRODUCES: APPLICATION/VND.CONVERSION.SIMPLE+JSON) https://api-demo.wolkabout.com/api/conversions HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/conversions',
  method: 'GET (produces: application/vnd.conversion.simple+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/conversions',
{
  method: 'GET (PRODUCES: APPLICATION/VND.CONVERSION.SIMPLE+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET (produces: application/vnd.conversion.simple+json) 'https://api-demo.wolkabout.com/api/conversions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET (produces: application/vnd.conversion.simple+json)('https://api-demo.wolkabout.com/api/conversions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/conversions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET (PRODUCES: APPLICATION/VND.CONVERSION.SIMPLE+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET (PRODUCES: APPLICATION/VND.CONVERSION.SIMPLE+JSON)", "https://api-demo.wolkabout.com/api/conversions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET (PRODUCES: APPLICATION/VND.CONVERSION.SIMPLE+JSON) /api/conversions

listSimple

Permissions:
isAuthenticated()

Description:
Returns units with conversion compatible to provided unit, or all units.

Parameters

Parameter	In	Type	Required	Description
from	query	undefined	false	from

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

createUsingPOST

# You can also use wget
curl -X POST https://api-demo.wolkabout.com/api/conversions \
  -H 'Authorization: API_KEY'

POST https://api-demo.wolkabout.com/api/conversions HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/conversions',
  method: 'POST',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/conversions',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST 'https://api-demo.wolkabout.com/api/conversions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST('https://api-demo.wolkabout.com/api/conversions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/conversions");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-demo.wolkabout.com/api/conversions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/conversions

create

Permissions:
isAuthenticated()

Description:
Creates new conversion.

Parameters

Parameter	In	Type	Required	Description
conversion	body	Conversion	true	conversion

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

listUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/conversions \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/conversions HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/conversions',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/conversions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/conversions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/conversions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/conversions");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/conversions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/conversions

list

Permissions:
isAuthenticated()

Description:
Returns filtered list of conversions.

Parameters

Parameter	In	Type	Required	Description
readingTypeId	query	undefined	false	readingTypeId
unit	query	undefined	false	unit

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

listPagedUsingGET

# You can also use wget
curl -X GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/conversions \
  -H 'Authorization: API_KEY'

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/conversions HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/conversions',
  method: 'GET (produces: application/vnd.page+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/conversions',
{
  method: 'GET (PRODUCES: APPLICATION/VND.PAGE+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET (produces: application/vnd.page+json) 'https://api-demo.wolkabout.com/api/conversions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET (produces: application/vnd.page+json)('https://api-demo.wolkabout.com/api/conversions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/conversions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET (PRODUCES: APPLICATION/VND.PAGE+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET (PRODUCES: APPLICATION/VND.PAGE+JSON)", "https://api-demo.wolkabout.com/api/conversions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) /api/conversions

listPaged

Permissions:
isAuthenticated()

Description:
Returns filtered and paged list of conversions.

Parameters

Parameter	In	Type	Required	Description
readingTypeId	query	undefined	false	readingTypeId
unit	query	undefined	false	unit

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

deleteConversionUsingDELETE

# You can also use wget
curl -X DELETE https://api-demo.wolkabout.com/api/conversions/{id} \
  -H 'Authorization: API_KEY'

DELETE https://api-demo.wolkabout.com/api/conversions/{id} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/conversions/{id}',
  method: 'DELETE',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/conversions/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.DELETE 'https://api-demo.wolkabout.com/api/conversions/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.DELETE('https://api-demo.wolkabout.com/api/conversions/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/conversions/{id}");
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() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-demo.wolkabout.com/api/conversions/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/conversions/{id}

deleteConversion

Permissions:
isAuthenticated()

Description:
Deletes conversion based on id.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

readUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/conversions/{id} \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/conversions/{id} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/conversions/{id}',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/conversions/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/conversions/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/conversions/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/conversions/{id}");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/conversions/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/conversions/{id}

read

Permissions:
isAuthenticated()

Description:
Returns conversion by id.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/conversions/{id} \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/conversions/{id} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/conversions/{id}',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/conversions/{id}',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/conversions/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/conversions/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/conversions/{id}");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/conversions/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/conversions/{id}

update

Permissions:
isAuthenticated()

Description:
Updates conversion.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id
update	body	Conversion	true	update

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

global-role-api

listPermissionsUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/globalRoles/{roleId}/permissions \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/globalRoles/{roleId}/permissions HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles/{roleId}/permissions',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/globalRoles/{roleId}/permissions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/globalRoles/{roleId}/permissions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/globalRoles/{roleId}/permissions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles/{roleId}/permissions");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/globalRoles/{roleId}/permissions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/globalRoles/{roleId}/permissions

listPermissions

Permissions:
isAuthenticated()

Description:
Returns a list of all permissions that the global role has.

Parameters

Parameter	In	Type	Required	Description
roleId	path	undefined	true	roleId

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

deleteRoleUsingDELETE

# You can also use wget
curl -X DELETE https://api-demo.wolkabout.com/api/globalRoles/{roleId} \
  -H 'Authorization: API_KEY'

DELETE https://api-demo.wolkabout.com/api/globalRoles/{roleId} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles/{roleId}',
  method: 'DELETE',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/globalRoles/{roleId}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.DELETE 'https://api-demo.wolkabout.com/api/globalRoles/{roleId}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.DELETE('https://api-demo.wolkabout.com/api/globalRoles/{roleId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles/{roleId}");
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() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-demo.wolkabout.com/api/globalRoles/{roleId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/globalRoles/{roleId}

deleteRole

Permissions:
isAuthenticated()

Description:
Deletes the user created global role.

Parameters

Parameter	In	Type	Required	Description
roleId	path	undefined	true	roleId

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

getRoleUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/globalRoles/{roleId} \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/globalRoles/{roleId} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles/{roleId}',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/globalRoles/{roleId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/globalRoles/{roleId}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/globalRoles/{roleId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles/{roleId}");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/globalRoles/{roleId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/globalRoles/{roleId}

getRole

Permissions:
isAuthenticated()

Description:
Returns the global role by id.

Parameters

Parameter	In	Type	Required	Description
roleId	path	undefined	true	roleId

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateRoleUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/globalRoles/{roleId} \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/globalRoles/{roleId} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles/{roleId}',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/globalRoles/{roleId}',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/globalRoles/{roleId}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/globalRoles/{roleId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles/{roleId}");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/globalRoles/{roleId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/globalRoles/{roleId}

updateRole

Permissions:
isAuthenticated()

Description:
Updates the user created global role.

Parameters

Parameter	In	Type	Required	Description
roleId	path	undefined	true	roleId
update	body	GlobalRoleDto	true	update

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

deleteRolesUsingDELETE

# You can also use wget
curl -X DELETE https://api-demo.wolkabout.com/api/globalRoles \
  -H 'Authorization: API_KEY'

DELETE https://api-demo.wolkabout.com/api/globalRoles HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles',
  method: 'DELETE',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/globalRoles',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.DELETE 'https://api-demo.wolkabout.com/api/globalRoles',
  params: {
  'ids' => 'undefined'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.DELETE('https://api-demo.wolkabout.com/api/globalRoles', params={
  'ids': undefined
}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles");
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() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-demo.wolkabout.com/api/globalRoles", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/globalRoles

deleteRoles

Permissions:
isAuthenticated()

Description:
Deletes many user created global roles by id.

Parameters

Parameter	In	Type	Required	Description
ids	query	undefined	true	ids

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

createRoleUsingPOST

# You can also use wget
curl -X POST https://api-demo.wolkabout.com/api/globalRoles \
  -H 'Authorization: API_KEY'

POST https://api-demo.wolkabout.com/api/globalRoles HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles',
  method: 'POST',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/globalRoles',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST 'https://api-demo.wolkabout.com/api/globalRoles',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST('https://api-demo.wolkabout.com/api/globalRoles', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-demo.wolkabout.com/api/globalRoles", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/globalRoles

createRole

Permissions:
isAuthenticated()

Description:
Creates a new global role.

Parameters

Parameter	In	Type	Required	Description
dto	body	GlobalRoleDto	true	dto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

listUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/globalRoles \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/globalRoles HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/globalRoles',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/globalRoles',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/globalRoles', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/globalRoles", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/globalRoles

list

Permissions:
isAuthenticated()

Description:
Returns a filtered list of global roles.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

listPagedUsingGET

# You can also use wget
curl -X GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/globalRoles \
  -H 'Authorization: API_KEY'

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/globalRoles HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles',
  method: 'GET (produces: application/vnd.page+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/globalRoles',
{
  method: 'GET (PRODUCES: APPLICATION/VND.PAGE+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET (produces: application/vnd.page+json) 'https://api-demo.wolkabout.com/api/globalRoles',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET (produces: application/vnd.page+json)('https://api-demo.wolkabout.com/api/globalRoles', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET (PRODUCES: APPLICATION/VND.PAGE+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET (PRODUCES: APPLICATION/VND.PAGE+JSON)", "https://api-demo.wolkabout.com/api/globalRoles", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) /api/globalRoles

listPaged

Permissions:
isAuthenticated()

Description:
Returns a filtered and paged list of global roles.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

roleImportUsingPOST

# You can also use wget
curl -X POST (CONTENT-TYPE: MULTIPART/FORM-DATA) https://api-demo.wolkabout.com/api/globalRoles/import \
  -H 'Authorization: API_KEY'

POST (CONTENT-TYPE: MULTIPART/FORM-DATA) https://api-demo.wolkabout.com/api/globalRoles/import HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles/import',
  method: 'POST (Content-Type: multipart/form-data)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/globalRoles/import',
{
  method: 'POST (CONTENT-TYPE: MULTIPART/FORM-DATA)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST (Content-Type: multipart/form-data) 'https://api-demo.wolkabout.com/api/globalRoles/import',
  params: {
  'file' => 'undefined'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST (Content-Type: multipart/form-data)('https://api-demo.wolkabout.com/api/globalRoles/import', params={
  'file': undefined
}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles/import");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST (CONTENT-TYPE: MULTIPART/FORM-DATA)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST (CONTENT-TYPE: MULTIPART/FORM-DATA)", "https://api-demo.wolkabout.com/api/globalRoles/import", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST (CONTENT-TYPE: MULTIPART/FORM-DATA) /api/globalRoles/import

roleImport

Permissions:
isAuthenticated()

Description:
Import global roles from a file. In case of a failed import all imports are reverted i.e everything is imported or nothing is.

Parameters

Parameter	In	Type	Required	Description
file	query	undefined	true	file

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

exportByCriteriaUsingGET

# You can also use wget
curl -X GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON) https://api-demo.wolkabout.com/api/globalRoles/export \
  -H 'Authorization: API_KEY'

GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON) https://api-demo.wolkabout.com/api/globalRoles/export HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles/export',
  method: 'GET (produces: application/vnd.criteria.operation+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/globalRoles/export',
{
  method: 'GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET (produces: application/vnd.criteria.operation+json) 'https://api-demo.wolkabout.com/api/globalRoles/export',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET (produces: application/vnd.criteria.operation+json)('https://api-demo.wolkabout.com/api/globalRoles/export', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles/export");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON)", "https://api-demo.wolkabout.com/api/globalRoles/export", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON) /api/globalRoles/export

exportByCriteria

Permissions:
isAuthenticated()

Description:
Exports global roles as dto. Only role name is searched with query parameter.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

exportByIdUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/globalRoles/export \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/globalRoles/export HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles/export',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/globalRoles/export',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/globalRoles/export',
  params: {
  'ids' => 'undefined'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/globalRoles/export', params={
  'ids': undefined
}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles/export");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/globalRoles/export", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/globalRoles/export

exportById

Permissions:
isAuthenticated()

Description:
Exports global roles as dto.

Parameters

Parameter	In	Type	Required	Description
ids	query	undefined	true	ids

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

getInitialTreeUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/globalRoles/initialTree

GET https://api-demo.wolkabout.com/api/globalRoles/initialTree HTTP/1.1
Host: api-demo.wolkabout.com


$.ajax({
  url: 'https://api-demo.wolkabout.com/api/globalRoles/initialTree',
  method: 'GET',

  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

fetch('https://api-demo.wolkabout.com/api/globalRoles/initialTree',
{
  method: 'GET'

})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

result = RestClient.GET 'https://api-demo.wolkabout.com/api/globalRoles/initialTree',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.GET('https://api-demo.wolkabout.com/api/globalRoles/initialTree', params={

)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/globalRoles/initialTree");
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", "https://api-demo.wolkabout.com/api/globalRoles/initialTree", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/globalRoles/initialTree

getInitialTree

Permissions:
isAuthenticated()

Description:
Returns the tree that contains all possible global permissions.

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
404	Not Found	Not Found	None

profile-api

myPermissionsUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/users/me/permissions \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/users/me/permissions HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/users/me/permissions',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/users/me/permissions',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/users/me/permissions',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/users/me/permissions', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/users/me/permissions");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/users/me/permissions", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/users/me/permissions

myPermissions

Permissions:
isAuthenticated()

Description:
Returns a list of the users global permissions.

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

userUpdateNameUsingPUT

# You can also use wget
curl -X PUT (PRODUCES: APPLICATION/VND.NOEMAIL.V1+JSON) https://api-demo.wolkabout.com/api/users/me \
  -H 'Authorization: API_KEY'

PUT (PRODUCES: APPLICATION/VND.NOEMAIL.V1+JSON) https://api-demo.wolkabout.com/api/users/me HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/users/me',
  method: 'PUT (produces: application/vnd.noemail.v1+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/users/me',
{
  method: 'PUT (PRODUCES: APPLICATION/VND.NOEMAIL.V1+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT (produces: application/vnd.noemail.v1+json) 'https://api-demo.wolkabout.com/api/users/me',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT (produces: application/vnd.noemail.v1+json)('https://api-demo.wolkabout.com/api/users/me', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/users/me");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT (PRODUCES: APPLICATION/VND.NOEMAIL.V1+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT (PRODUCES: APPLICATION/VND.NOEMAIL.V1+JSON)", "https://api-demo.wolkabout.com/api/users/me", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT (PRODUCES: APPLICATION/VND.NOEMAIL.V1+JSON) /api/users/me

userUpdateName

Permissions:
isAuthenticated()

Description:
Updates the users name.

Parameters

Parameter	In	Type	Required	Description
updateDto	body	UserUpdateDto	true	updateDto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

deleteMeFromAllContextsUsingPOST

# You can also use wget
curl -X POST (PRODUCES: APPLICATION/VND.DELETE+JSON) https://api-demo.wolkabout.com/api/users/me \
  -H 'Authorization: API_KEY'

POST (PRODUCES: APPLICATION/VND.DELETE+JSON) https://api-demo.wolkabout.com/api/users/me HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/users/me',
  method: 'POST (produces: application/vnd.delete+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/users/me',
{
  method: 'POST (PRODUCES: APPLICATION/VND.DELETE+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST (produces: application/vnd.delete+json) 'https://api-demo.wolkabout.com/api/users/me',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST (produces: application/vnd.delete+json)('https://api-demo.wolkabout.com/api/users/me', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/users/me");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST (PRODUCES: APPLICATION/VND.DELETE+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST (PRODUCES: APPLICATION/VND.DELETE+JSON)", "https://api-demo.wolkabout.com/api/users/me", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST (PRODUCES: APPLICATION/VND.DELETE+JSON) /api/users/me

deleteMeFromAllContexts

Permissions:
isAuthenticated()

Description:
Deletes the user from all contexts.

Parameters

Parameter	In	Type	Required	Description
password	body	String	true	password

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

getProfileUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/users/me \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/users/me HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/users/me',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/users/me',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/users/me',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/users/me', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/users/me");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/users/me", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/users/me

getProfile

Permissions:
isAuthenticated()

Description:
Returns the users profile.

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

userUpdateUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/users/me \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/users/me HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/users/me',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/users/me',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/users/me',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/users/me', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/users/me");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/users/me", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/users/me

userUpdate

Permissions:
isAuthenticated()

Description:
Updates the user.

Parameters

Parameter	In	Type	Required	Description
updateDto	body	UserUpdateWithEmailDto	true	updateDto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

getHttpPublishingKeyUsingPOST

# You can also use wget
curl -X POST https://api-demo.wolkabout.com/api/users/me/httpPublishingKey \
  -H 'Authorization: API_KEY'

POST https://api-demo.wolkabout.com/api/users/me/httpPublishingKey HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/users/me/httpPublishingKey',
  method: 'POST',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/users/me/httpPublishingKey',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST 'https://api-demo.wolkabout.com/api/users/me/httpPublishingKey',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST('https://api-demo.wolkabout.com/api/users/me/httpPublishingKey', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/users/me/httpPublishingKey");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-demo.wolkabout.com/api/users/me/httpPublishingKey", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/users/me/httpPublishingKey

getHttpPublishingKey

Permissions:
isAuthenticated()

Description:
Creates and returns a HTTP publishing key for the user.

Parameters

Parameter	In	Type	Required	Description
expirationDate	body	long	true	expirationDate

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

passwordChangeUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/users/me/passwordChange \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/users/me/passwordChange HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/users/me/passwordChange',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/users/me/passwordChange',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/users/me/passwordChange',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/users/me/passwordChange', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/users/me/passwordChange");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/users/me/passwordChange", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/users/me/passwordChange

passwordChange

Permissions:
isAuthenticated()

Description:
Updates the users password.

Parameters

Parameter	In	Type	Required	Description
request	body	ChangePasswordRequest	true	request

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

getAccessKeyUsingPOST

# You can also use wget
curl -X POST https://api-demo.wolkabout.com/api/users/me/accessKey \
  -H 'Authorization: API_KEY'

POST https://api-demo.wolkabout.com/api/users/me/accessKey HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/users/me/accessKey',
  method: 'POST',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/users/me/accessKey',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST 'https://api-demo.wolkabout.com/api/users/me/accessKey',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST('https://api-demo.wolkabout.com/api/users/me/accessKey', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/users/me/accessKey");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-demo.wolkabout.com/api/users/me/accessKey", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/users/me/accessKey

getAccessKey

Permissions:
isAuthenticated()

Description:
Creates and returns an access key with the provided permission for the user.

Parameters

Parameter	In	Type	Required	Description
permissions	query	undefined	false	permissions
expirationDate	body	long	true	expirationDate

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

reading-type-api

importReadingTypeUsingPOST

# You can also use wget
curl -X POST (CONTENT-TYPE: MULTIPART/FORM-DATA) https://api-demo.wolkabout.com/api/readingTypes/import \
  -H 'Authorization: API_KEY'

POST (CONTENT-TYPE: MULTIPART/FORM-DATA) https://api-demo.wolkabout.com/api/readingTypes/import HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/import',
  method: 'POST (Content-Type: multipart/form-data)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/import',
{
  method: 'POST (CONTENT-TYPE: MULTIPART/FORM-DATA)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST (Content-Type: multipart/form-data) 'https://api-demo.wolkabout.com/api/readingTypes/import',
  params: {
  'file' => 'undefined'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST (Content-Type: multipart/form-data)('https://api-demo.wolkabout.com/api/readingTypes/import', params={
  'file': undefined
}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/import");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST (CONTENT-TYPE: MULTIPART/FORM-DATA)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST (CONTENT-TYPE: MULTIPART/FORM-DATA)", "https://api-demo.wolkabout.com/api/readingTypes/import", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST (CONTENT-TYPE: MULTIPART/FORM-DATA) /api/readingTypes/import

importReadingType

Permissions:
isAuthenticated()

Description:
Imports reading types and units based on GUID. If units required are missing import will not be successful.

Parameters

Parameter	In	Type	Required	Description
file	query	undefined	true	file

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

deleteReadingTypeUsingDELETE

# You can also use wget
curl -X DELETE https://api-demo.wolkabout.com/api/readingTypes/{id} \
  -H 'Authorization: API_KEY'

DELETE https://api-demo.wolkabout.com/api/readingTypes/{id} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/{id}',
  method: 'DELETE',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/{id}',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.DELETE 'https://api-demo.wolkabout.com/api/readingTypes/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.DELETE('https://api-demo.wolkabout.com/api/readingTypes/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/{id}");
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() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-demo.wolkabout.com/api/readingTypes/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/readingTypes/{id}

deleteReadingType

Permissions:
isAuthenticated()

Description:
Deletes the reading type.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

getReadingTypeUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/readingTypes/{id} \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/readingTypes/{id} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/{id}',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/{id}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/readingTypes/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/readingTypes/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/{id}");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/readingTypes/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/readingTypes/{id}

getReadingType

Permissions:
isAuthenticated()

Description:
Returns the reading type by id.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateReadingTypeUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/readingTypes/{id} \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/readingTypes/{id} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/{id}',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/{id}',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/readingTypes/{id}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/readingTypes/{id}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/{id}");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/readingTypes/{id}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/readingTypes/{id}

updateReadingType

Permissions:
isAuthenticated()

Description:
Updates the reading type.

Parameters

Parameter	In	Type	Required	Description
iconName	query	undefined	false	iconName
id	path	undefined	true	id
update	body	ReadingType	true	update

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

bulkDeleteReadingTypeUsingDELETE

# You can also use wget
curl -X DELETE https://api-demo.wolkabout.com/api/readingTypes \
  -H 'Authorization: API_KEY'

DELETE https://api-demo.wolkabout.com/api/readingTypes HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes',
  method: 'DELETE',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes',
{
  method: 'DELETE',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.DELETE 'https://api-demo.wolkabout.com/api/readingTypes',
  params: {
  'ids' => 'undefined'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.DELETE('https://api-demo.wolkabout.com/api/readingTypes', params={
  'ids': undefined
}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes");
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() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api-demo.wolkabout.com/api/readingTypes", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

DELETE /api/readingTypes

bulkDeleteReadingType

Permissions:
isAuthenticated()

Description:
Deletes multiple reading types by ids.

Parameters

Parameter	In	Type	Required	Description
ids	query	undefined	true	ids

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

createReadingTypeUsingPOST

# You can also use wget
curl -X POST https://api-demo.wolkabout.com/api/readingTypes \
  -H 'Authorization: API_KEY'

POST https://api-demo.wolkabout.com/api/readingTypes HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes',
  method: 'POST',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST 'https://api-demo.wolkabout.com/api/readingTypes',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST('https://api-demo.wolkabout.com/api/readingTypes', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-demo.wolkabout.com/api/readingTypes", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/readingTypes

createReadingType

Permissions:
isAuthenticated()

Description:
Creates a new reading type.

Parameters

Parameter	In	Type	Required	Description
iconName	query	undefined	false	iconName
dto	body	ReadingTypeCreationDto	true	dto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

listUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/readingTypes \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/readingTypes HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/readingTypes',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/readingTypes', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/readingTypes", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/readingTypes

list

Permissions:
isAuthenticated()

Description:
Returns a filtered list of reading types.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query
queryExclude	query	undefined	false	queryExclude
image	query	undefined	false	image
color	query	undefined	false	color
dataType	query	undefined	false	dataType
dataSize	query	undefined	false	dataSize
system	query	undefined	false	system

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

pageUsingGET

# You can also use wget
curl -X GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/readingTypes \
  -H 'Authorization: API_KEY'

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/readingTypes HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes',
  method: 'GET (produces: application/vnd.page+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes',
{
  method: 'GET (PRODUCES: APPLICATION/VND.PAGE+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET (produces: application/vnd.page+json) 'https://api-demo.wolkabout.com/api/readingTypes',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET (produces: application/vnd.page+json)('https://api-demo.wolkabout.com/api/readingTypes', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET (PRODUCES: APPLICATION/VND.PAGE+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET (PRODUCES: APPLICATION/VND.PAGE+JSON)", "https://api-demo.wolkabout.com/api/readingTypes", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) /api/readingTypes

page

Permissions:
isAuthenticated()

Description:
Returns a filtered and paged list of reading types.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query
queryExclude	query	undefined	false	queryExclude
image	query	undefined	false	image
color	query	undefined	false	color
dataType	query	undefined	false	dataType
dataSize	query	undefined	false	dataSize
system	query	undefined	false	system

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

createUnitUsingPOST

# You can also use wget
curl -X POST https://api-demo.wolkabout.com/api/readingTypes/{id}/units \
  -H 'Authorization: API_KEY'

POST https://api-demo.wolkabout.com/api/readingTypes/{id}/units HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/{id}/units',
  method: 'POST',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/{id}/units',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST 'https://api-demo.wolkabout.com/api/readingTypes/{id}/units',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST('https://api-demo.wolkabout.com/api/readingTypes/{id}/units', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/{id}/units");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-demo.wolkabout.com/api/readingTypes/{id}/units", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/readingTypes/{id}/units

createUnit

Permissions:
isAuthenticated()

Description:
Creates a unit for the reading type.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id
unit	body	Unit	true	unit

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

getUnitUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId} \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/readingTypes/{id}/units/{unitId}

getUnit

Permissions:
isAuthenticated()

Description:
Returns the unit on the reading type by id.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id
unitId	path	undefined	true	unitId

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateUnitUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId} \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/readingTypes/{id}/units/{unitId}

updateUnit

Permissions:
isAuthenticated()

Description:
Updates the unit on the reading type. Update of name and system will not be done for system units and ones that are in use.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id
unitId	path	undefined	true	unitId
update	body	Unit	true	update

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateUnitPrecisionUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}/precision \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}/precision HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}/precision',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}/precision',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}/precision',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}/precision', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}/precision");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/readingTypes/{id}/units/{unitId}/precision", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/readingTypes/{id}/units/{unitId}/precision

updateUnitPrecision

Permissions:
isAuthenticated()

Description:
Updates the precision of the unit on the reading type.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id
unitId	path	undefined	true	unitId
precision	body	int	true	precision

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

exportReadingTypeByCriteriaUsingGET

# You can also use wget
curl -X GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON) https://api-demo.wolkabout.com/api/readingTypes/export \
  -H 'Authorization: API_KEY'

GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON) https://api-demo.wolkabout.com/api/readingTypes/export HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/export',
  method: 'GET (produces: application/vnd.criteria.operation+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/export',
{
  method: 'GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET (produces: application/vnd.criteria.operation+json) 'https://api-demo.wolkabout.com/api/readingTypes/export',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET (produces: application/vnd.criteria.operation+json)('https://api-demo.wolkabout.com/api/readingTypes/export', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/export");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON)", "https://api-demo.wolkabout.com/api/readingTypes/export", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET (PRODUCES: APPLICATION/VND.CRITERIA.OPERATION+JSON) /api/readingTypes/export

exportReadingTypeByCriteria

Permissions:
isAuthenticated()

Description:
Exports reading types and units based on criteria.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query
system	query	undefined	false	system

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

exportReadingTypesUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/readingTypes/export \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/readingTypes/export HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/export',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/export',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/readingTypes/export',
  params: {
  'ids' => 'undefined'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/readingTypes/export', params={
  'ids': undefined
}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/export");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/readingTypes/export", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/readingTypes/export

exportReadingTypes

Permissions:
isAuthenticated()

Description:
Exports reading types and units based on ids.

Parameters

Parameter	In	Type	Required	Description
ids	query	undefined	true	ids

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateReadingTypeIconUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/readingTypes/{id}/icon \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/readingTypes/{id}/icon HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/{id}/icon',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/{id}/icon',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/readingTypes/{id}/icon',
  params: {
  'name' => 'undefined'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/readingTypes/{id}/icon', params={
  'name': undefined
}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/{id}/icon");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/readingTypes/{id}/icon", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/readingTypes/{id}/icon

updateReadingTypeIcon

Permissions:
isAuthenticated()

Description:
Updates icon for existing reading type. This operation is allowed on reading types that are in use.

Parameters

Parameter	In	Type	Required	Description
name	query	undefined	true	name
id	path	undefined	true	id

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

reading-type-image-api

imagePngUsingGET

# You can also use wget
curl -X GET (PRODUCES: IMAGE/PNG) https://api-demo.wolkabout.com/api/readingTypes/{id}/image

GET (PRODUCES: IMAGE/PNG) https://api-demo.wolkabout.com/api/readingTypes/{id}/image HTTP/1.1
Host: api-demo.wolkabout.com


$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/{id}/image',
  method: 'GET (produces: image/png)',

  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

fetch('https://api-demo.wolkabout.com/api/readingTypes/{id}/image',
{
  method: 'GET (PRODUCES: IMAGE/PNG)'

})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

result = RestClient.GET (produces: image/png) 'https://api-demo.wolkabout.com/api/readingTypes/{id}/image',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.GET (produces: image/png)('https://api-demo.wolkabout.com/api/readingTypes/{id}/image', params={

)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/{id}/image");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET (PRODUCES: IMAGE/PNG)");
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 (PRODUCES: IMAGE/PNG)", "https://api-demo.wolkabout.com/api/readingTypes/{id}/image", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET (PRODUCES: IMAGE/PNG) /api/readingTypes/{id}/image

imagePng

Permissions:

Description:
Returns the image associated with the reading type as png.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
404	Not Found	Not Found	None

getIconsPngUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/readingTypes/pngimages \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/readingTypes/pngimages HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/pngimages',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/pngimages',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/readingTypes/pngimages',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/readingTypes/pngimages', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/pngimages");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/readingTypes/pngimages", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/readingTypes/pngimages

getIconsPng

Permissions:
isAuthenticated()

Description:
Returns a list of the png icons of all reading types that match the query.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

getLibraryUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/readingTypes/library

GET https://api-demo.wolkabout.com/api/readingTypes/library HTTP/1.1
Host: api-demo.wolkabout.com


$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/library',
  method: 'GET',

  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

fetch('https://api-demo.wolkabout.com/api/readingTypes/library',
{
  method: 'GET'

})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

result = RestClient.GET 'https://api-demo.wolkabout.com/api/readingTypes/library',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.GET('https://api-demo.wolkabout.com/api/readingTypes/library', params={

)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/library");
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", "https://api-demo.wolkabout.com/api/readingTypes/library", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/readingTypes/library

getLibrary

Permissions:
isAuthenticated()

Description:
Returns list of all reading type svg images.

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
404	Not Found	Not Found	None

imageSvgByIconNameUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/readingTypes/{name}/icon.svg

GET https://api-demo.wolkabout.com/api/readingTypes/{name}/icon.svg HTTP/1.1
Host: api-demo.wolkabout.com


$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/{name}/icon.svg',
  method: 'GET',

  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

fetch('https://api-demo.wolkabout.com/api/readingTypes/{name}/icon.svg',
{
  method: 'GET'

})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

result = RestClient.GET 'https://api-demo.wolkabout.com/api/readingTypes/{name}/icon.svg',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.GET('https://api-demo.wolkabout.com/api/readingTypes/{name}/icon.svg', params={

)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/{name}/icon.svg");
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", "https://api-demo.wolkabout.com/api/readingTypes/{name}/icon.svg", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/readingTypes/{name}/icon.svg

imageSvgByIconName

Permissions:

Description:
Returns svg image by name.

Parameters

Parameter	In	Type	Required	Description
color	query	undefined	false	color
name	path	undefined	true	name

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
404	Not Found	Not Found	None

imageSvgUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/readingTypes/{id}/image.svg

GET https://api-demo.wolkabout.com/api/readingTypes/{id}/image.svg HTTP/1.1
Host: api-demo.wolkabout.com


$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/{id}/image.svg',
  method: 'GET',

  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

fetch('https://api-demo.wolkabout.com/api/readingTypes/{id}/image.svg',
{
  method: 'GET'

})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

result = RestClient.GET 'https://api-demo.wolkabout.com/api/readingTypes/{id}/image.svg',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.GET('https://api-demo.wolkabout.com/api/readingTypes/{id}/image.svg', params={

)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/{id}/image.svg");
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", "https://api-demo.wolkabout.com/api/readingTypes/{id}/image.svg", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/readingTypes/{id}/image.svg

imageSvg

Permissions:

Description:
Returns the image associated with the reading type as svg.

Parameters

Parameter	In	Type	Required	Description
color	query	undefined	false	color
id	path	undefined	true	id

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
404	Not Found	Not Found	None

getIconsSvgUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/readingTypes/svgimages \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/readingTypes/svgimages HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/svgimages',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/svgimages',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/readingTypes/svgimages',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/readingTypes/svgimages', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/svgimages");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/readingTypes/svgimages", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/readingTypes/svgimages

getIconsSvg

Permissions:
isAuthenticated()

Description:
Returns a list of the svg icons of all reading types that match the query.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

getIconsSvgPageUsingGET

# You can also use wget
curl -X GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/readingTypes/svgimages \
  -H 'Authorization: API_KEY'

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/readingTypes/svgimages HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/readingTypes/svgimages',
  method: 'GET (produces: application/vnd.page+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/readingTypes/svgimages',
{
  method: 'GET (PRODUCES: APPLICATION/VND.PAGE+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET (produces: application/vnd.page+json) 'https://api-demo.wolkabout.com/api/readingTypes/svgimages',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET (produces: application/vnd.page+json)('https://api-demo.wolkabout.com/api/readingTypes/svgimages', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/readingTypes/svgimages");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET (PRODUCES: APPLICATION/VND.PAGE+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET (PRODUCES: APPLICATION/VND.PAGE+JSON)", "https://api-demo.wolkabout.com/api/readingTypes/svgimages", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) /api/readingTypes/svgimages

getIconsSvgPage

Permissions:
isAuthenticated()

Description:
Returns a paged list of the svg icons of all reading types that match the query.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

tenant-api

updateNameUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/myTenant/name \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/myTenant/name HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/myTenant/name',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/myTenant/name',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/myTenant/name',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/myTenant/name', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/myTenant/name");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/myTenant/name", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/myTenant/name

updateName

Permissions:
isAuthenticated()

Description:
Updates the name of the current tenant.

Parameters

Parameter	In	Type	Required	Description
name	body	String	true	name

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

listUsersByContextUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/tenants/myTenant/users \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/tenants/myTenant/users HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/myTenant/users',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/myTenant/users',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/tenants/myTenant/users',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/tenants/myTenant/users', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/myTenant/users");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/tenants/myTenant/users", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/tenants/myTenant/users

listUsersByContext

Permissions:
isAuthenticated()

Description:
Returns a filtered list of users on the current tenant.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

pageUsersByContextUsingGET

# You can also use wget
curl -X GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/tenants/myTenant/users \
  -H 'Authorization: API_KEY'

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/tenants/myTenant/users HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/myTenant/users',
  method: 'GET (produces: application/vnd.page+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/myTenant/users',
{
  method: 'GET (PRODUCES: APPLICATION/VND.PAGE+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET (produces: application/vnd.page+json) 'https://api-demo.wolkabout.com/api/tenants/myTenant/users',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET (produces: application/vnd.page+json)('https://api-demo.wolkabout.com/api/tenants/myTenant/users', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/myTenant/users");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET (PRODUCES: APPLICATION/VND.PAGE+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET (PRODUCES: APPLICATION/VND.PAGE+JSON)", "https://api-demo.wolkabout.com/api/tenants/myTenant/users", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) /api/tenants/myTenant/users

pageUsersByContext

Permissions:
isAuthenticated()

Description:
Returns a filtered and paged list of users on the current tenant.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

getUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/tenants/myTenant \
  -H 'Authorization: API_KEY'

GET https://api-demo.wolkabout.com/api/tenants/myTenant HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/myTenant',
  method: 'GET',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/myTenant',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.GET 'https://api-demo.wolkabout.com/api/tenants/myTenant',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.GET('https://api-demo.wolkabout.com/api/tenants/myTenant', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/myTenant");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api-demo.wolkabout.com/api/tenants/myTenant", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/tenants/myTenant

get

Permissions:
isAuthenticated()

Description:
Returns information about the current tenant.

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/myTenant \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/myTenant HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/myTenant',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/myTenant',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/myTenant',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/myTenant', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/myTenant");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/myTenant", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/myTenant

update

Permissions:
isAuthenticated()

Description:
Updates the current tenant.

Parameters

Parameter	In	Type	Required	Description
dto	body	TenantUpdateDto	true	dto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

changeOwnerUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/myTenant/owner \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/myTenant/owner HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/myTenant/owner',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/myTenant/owner',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/myTenant/owner',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/myTenant/owner', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/myTenant/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() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/myTenant/owner", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/myTenant/owner

changeOwner

Permissions:
isAuthenticated()

Description:
Changes the owner of the current tenant.

Parameters

Parameter	In	Type	Required	Description
dto	body	TenantTransferOwnershipDto	true	dto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateDefaultRoleUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/myTenant/defaultRole \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/myTenant/defaultRole HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/myTenant/defaultRole',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/myTenant/defaultRole',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/myTenant/defaultRole',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/myTenant/defaultRole', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/myTenant/defaultRole");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/myTenant/defaultRole", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/myTenant/defaultRole

updateDefaultRole

Permissions:
isAuthenticated()

Description:
Updates the default role on the current tenant.

Parameters

Parameter	In	Type	Required	Description
roleId	body	Long	true	roleId

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateLocalizationUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/myTenant/localization \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/myTenant/localization HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/myTenant/localization',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/myTenant/localization',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/myTenant/localization',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/myTenant/localization', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/myTenant/localization");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/myTenant/localization", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/myTenant/localization

updateLocalization

Permissions:
isAuthenticated()

Description:
Updates the localization properties of the current tenant.

Parameters

Parameter	In	Type	Required	Description
dto	body	LocalizationDto	true	dto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updatePropertiesUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/myTenant/properties \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/myTenant/properties HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/myTenant/properties',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/myTenant/properties',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/myTenant/properties',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/myTenant/properties', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/myTenant/properties");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/myTenant/properties", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/myTenant/properties

updateProperties

Permissions:
isAuthenticated()

Description:
Updates the properties of the current tenant.

Parameters

Parameter	In	Type	Required	Description
dto	body	TenantPropertiesDto	true	dto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

tenant-management-api

updateStatusUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/{id}/status \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/{id}/status HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/{id}/status',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/{id}/status',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/{id}/status',
  params: {
  'active' => 'undefined'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/{id}/status', params={
  'active': undefined
}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/{id}/status");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/{id}/status", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/{id}/status

updateStatus

Permissions:
isAuthenticated()

Description:
Sets the status to active/inactive.

Parameters

Parameter	In	Type	Required	Description
active	query	undefined	true	active
id	path	undefined	true	id
password	body	String	true	password

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateNameUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/{id}/name \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/{id}/name HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/{id}/name',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/{id}/name',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/{id}/name',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/{id}/name', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/{id}/name");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/{id}/name", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/{id}/name

updateName

Permissions:
isAuthenticated()

Description:
Updates the name of the tenant.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id
name	body	String	true	name

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

bulkDeleteUsingPOST

# You can also use wget
curl -X POST (PRODUCES: APPLICATION/VND.DELETE+JSON) https://api-demo.wolkabout.com/api/tenants \
  -H 'Authorization: API_KEY'

POST (PRODUCES: APPLICATION/VND.DELETE+JSON) https://api-demo.wolkabout.com/api/tenants HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants',
  method: 'POST (produces: application/vnd.delete+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants',
{
  method: 'POST (PRODUCES: APPLICATION/VND.DELETE+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST (produces: application/vnd.delete+json) 'https://api-demo.wolkabout.com/api/tenants',
  params: {
  'ids' => 'undefined'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST (produces: application/vnd.delete+json)('https://api-demo.wolkabout.com/api/tenants', params={
  'ids': undefined
}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST (PRODUCES: APPLICATION/VND.DELETE+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST (PRODUCES: APPLICATION/VND.DELETE+JSON)", "https://api-demo.wolkabout.com/api/tenants", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST (PRODUCES: APPLICATION/VND.DELETE+JSON) /api/tenants

bulkDelete

Permissions:
isAuthenticated()

Description:
Deletes multiple tenants.

Parameters

Parameter	In	Type	Required	Description
ids	query	undefined	true	ids
password	body	String	true	password

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

createUsingPOST

# You can also use wget
curl -X POST https://api-demo.wolkabout.com/api/tenants \
  -H 'Authorization: API_KEY'

POST https://api-demo.wolkabout.com/api/tenants HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants',
  method: 'POST',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST 'https://api-demo.wolkabout.com/api/tenants',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.POST('https://api-demo.wolkabout.com/api/tenants', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api-demo.wolkabout.com/api/tenants", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /api/tenants

create

Permissions:
isAuthenticated()

Description:
Creates a new tenant.

Parameters

Parameter	In	Type	Required	Description
dto	body	TenantDto	true	dto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

listUsingGET

# You can also use wget
curl -X GET https://api-demo.wolkabout.com/api/tenants

GET https://api-demo.wolkabout.com/api/tenants HTTP/1.1
Host: api-demo.wolkabout.com


$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants',
  method: 'GET',

  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

fetch('https://api-demo.wolkabout.com/api/tenants',
{
  method: 'GET'

})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

result = RestClient.GET 'https://api-demo.wolkabout.com/api/tenants',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.GET('https://api-demo.wolkabout.com/api/tenants', params={

)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants");
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", "https://api-demo.wolkabout.com/api/tenants", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/tenants

list

Permissions:
isAuthenticated()

Description:
Returns a filtered list of tenants.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query
active	query	undefined	false	active
verified	query	undefined	false	verified

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
404	Not Found	Not Found	None

pageUsingGET

# You can also use wget
curl -X GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/tenants

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) https://api-demo.wolkabout.com/api/tenants HTTP/1.1
Host: api-demo.wolkabout.com


$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants',
  method: 'GET (produces: application/vnd.page+json)',

  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

fetch('https://api-demo.wolkabout.com/api/tenants',
{
  method: 'GET (PRODUCES: APPLICATION/VND.PAGE+JSON)'

})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

result = RestClient.GET (produces: application/vnd.page+json) 'https://api-demo.wolkabout.com/api/tenants',
  params: {
  }

p JSON.parse(result)

import requests

r = requests.GET (produces: application/vnd.page+json)('https://api-demo.wolkabout.com/api/tenants', params={

)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET (PRODUCES: APPLICATION/VND.PAGE+JSON)");
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 (PRODUCES: APPLICATION/VND.PAGE+JSON)", "https://api-demo.wolkabout.com/api/tenants", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET (PRODUCES: APPLICATION/VND.PAGE+JSON) /api/tenants

page

Permissions:
isAuthenticated()

Description:
Returns a filtered and paged list of tenants.

Parameters

Parameter	In	Type	Required	Description
query	query	undefined	false	query
active	query	undefined	false	active
verified	query	undefined	false	verified

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
404	Not Found	Not Found	None

updateDefaultRoleUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/{id}/defaultRole \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/{id}/defaultRole HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/{id}/defaultRole',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/{id}/defaultRole',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/{id}/defaultRole',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/{id}/defaultRole', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/{id}/defaultRole");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/{id}/defaultRole", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/{id}/defaultRole

updateDefaultRole

Permissions:
isAuthenticated()

Description:
Updates the default role on the tenant.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id
roleId	body	Long	true	roleId

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateLocalizationUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/{id}/localization \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/{id}/localization HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/{id}/localization',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/{id}/localization',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/{id}/localization',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/{id}/localization', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/{id}/localization");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/{id}/localization", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/{id}/localization

updateLocalization

Permissions:
isAuthenticated()

Description:
Updates the localization properties of the tenant.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id
dto	body	LocalizationDto	true	dto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updateStatusBulkUsingPUT

# You can also use wget
curl -X PUT (PRODUCES: APPLICATION/VND.BULK.OPERATION+JSON) https://api-demo.wolkabout.com/api/tenants/status \
  -H 'Authorization: API_KEY'

PUT (PRODUCES: APPLICATION/VND.BULK.OPERATION+JSON) https://api-demo.wolkabout.com/api/tenants/status HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/status',
  method: 'PUT (produces: application/vnd.bulk.operation+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/status',
{
  method: 'PUT (PRODUCES: APPLICATION/VND.BULK.OPERATION+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT (produces: application/vnd.bulk.operation+json) 'https://api-demo.wolkabout.com/api/tenants/status',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT (produces: application/vnd.bulk.operation+json)('https://api-demo.wolkabout.com/api/tenants/status', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/status");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT (PRODUCES: APPLICATION/VND.BULK.OPERATION+JSON)");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT (PRODUCES: APPLICATION/VND.BULK.OPERATION+JSON)", "https://api-demo.wolkabout.com/api/tenants/status", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT (PRODUCES: APPLICATION/VND.BULK.OPERATION+JSON) /api/tenants/status

updateStatusBulk

Permissions:
isAuthenticated()

Description:
Updates the status of multiple tenants.

Parameters

Parameter	In	Type	Required	Description
update	body	TenantStatusBulkUpdateDto	true	update

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

changeOwnerUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/{id}/owner \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/{id}/owner HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/{id}/owner',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/{id}/owner',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/{id}/owner',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/{id}/owner', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/{id}/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() {

    headers := map[string][]string{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/{id}/owner", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/{id}/owner

changeOwner

Permissions:
isAuthenticated()

Description:
Changes the owner of the tenant.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id
dto	body	TenantTransferOwnershipDto	true	dto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

updatePropertiesUsingPUT

# You can also use wget
curl -X PUT https://api-demo.wolkabout.com/api/tenants/{id}/properties \
  -H 'Authorization: API_KEY'

PUT https://api-demo.wolkabout.com/api/tenants/{id}/properties HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/{id}/properties',
  method: 'PUT',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/{id}/properties',
{
  method: 'PUT',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.PUT 'https://api-demo.wolkabout.com/api/tenants/{id}/properties',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Authorization': 'API_KEY'
}

r = requests.PUT('https://api-demo.wolkabout.com/api/tenants/{id}/properties', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://api-demo.wolkabout.com/api/tenants/{id}/properties");
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{
        "Authorization": []string{"API_KEY"},

    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api-demo.wolkabout.com/api/tenants/{id}/properties", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

PUT /api/tenants/{id}/properties

updateProperties

Permissions:
isAuthenticated()

Description:
Updates the properties of the tenant.

Parameters

Parameter	In	Type	Required	Description
id	path	undefined	true	id
dto	body	TenantPropertiesUpdateDto	true	dto

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	None
404	Not Found	Not Found	None

deleteUsingPOST

# You can also use wget
curl -X POST (PRODUCES: APPLICATION/VND.DELETE+JSON) https://api-demo.wolkabout.com/api/tenants/{id} \
  -H 'Authorization: API_KEY'

POST (PRODUCES: APPLICATION/VND.DELETE+JSON) https://api-demo.wolkabout.com/api/tenants/{id} HTTP/1.1
Host: api-demo.wolkabout.com

var headers = {
  'Authorization':'API_KEY'

};

$.ajax({
  url: 'https://api-demo.wolkabout.com/api/tenants/{id}',
  method: 'POST (produces: application/vnd.delete+json)',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Authorization':'API_KEY'

};

fetch('https://api-demo.wolkabout.com/api/tenants/{id}',
{
  method: 'POST (PRODUCES: APPLICATION/VND.DELETE+JSON)',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Authorization' => 'API_KEY'
}

result = RestClient.POST (produces: application/vnd.delete+json)