Introduction
Pagination query params are as follows: page[size]=10&page[number]=1
This documentation aims to provide all the information you need to work with our API.
Authenticating requests
This API is authenticated by sending an Authorization
header with the value "Bearer {OPENID_CONNECT_TOKEN}"
.
All authenticated endpoints are marked with a requires authentication
badge in the documentation below.
Use OpenID Connect to retrieve a token. Instructions can be found here.
User
Me
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/user',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> '"points, points_formatted, reputations"',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/user"
);
const params = {
"include": ""points, points_formatted, reputations"",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/user?include=%22points%2C+points_formatted%2C+reputations%22" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"name": "Kyle",
"surname": "Schiller",
"email": "dejuan15@example.org",
"phone": "+1 (747) 478-7163",
"email_verified_at": "1992-05-16T03:26:45.000000Z",
"_key": null
}
}
Received response:
Request failed with error:
Update
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/user',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'ratione',
'surname' => 'possimus',
'phone' => 'dolores',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/user"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "ratione",
"surname": "possimus",
"phone": "dolores"
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/user" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"ratione\",
\"surname\": \"possimus\",
\"phone\": \"dolores\"
}"
Example response (200):
{
"data": {
"name": "Jude",
"surname": "Langosh",
"email": "jeanette98@example.net",
"phone": "269-595-0116",
"email_verified_at": "2006-06-09T07:53:00.000000Z",
"_key": null
}
}
Received response:
Request failed with error:
List Organizations
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/user/organizations',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/user/organizations"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/user/organizations" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"organization_id": "58633cf0-c16a-11ee-b850-9559b4333470",
"name": {
"en": "est"
},
"description": {
"en": "Quick, now!' And Alice was not here before,' said the Duchess, 'chop off her head!' Those whom she sentenced were taken into custody by the carrier,' she thought; 'and how funny it'll seem to have."
},
"parent_id": "59583c90-c16a-11ee-9675-1d0cfd6336c5",
"_key": null
},
{
"organization_id": "595a1280-c16a-11ee-af04-bd8757318f25",
"name": {
"en": "atque"
},
"description": {
"en": "White Rabbit put on his flappers, '--Mystery, ancient and modern, with Seaography: then Drawling--the Drawling-master was an immense length of neck, which seemed to Alice for some time after the."
},
"parent_id": "5a5c8740-c16a-11ee-bc8b-cb43b7f5c152",
"_key": null
}
]
}
Received response:
Request failed with error:
Create Organization
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/user/organizations',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'jzjy',
'slug' => 'ztstc',
'country_id' => 'cupiditate',
'domains' => [
'itaque',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/user/organizations"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "jzjy",
"slug": "ztstc",
"country_id": "cupiditate",
"domains": [
"itaque"
]
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/user/organizations" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"jzjy\",
\"slug\": \"ztstc\",
\"country_id\": \"cupiditate\",
\"domains\": [
\"itaque\"
]
}"
Example response (200):
{
"data": {
"name": "Organization architecto",
"country": "Guernsey",
"company_code": "sb-975",
"city": "North Daryl",
"address": "8943 Greyson Crossing Suite 569\nLake Nikitaside, MI 38663-0512",
"vat": "GB1076508932445",
"_key": null
}
}
Received response:
Request failed with error:
View Organization
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include=members-count'=> '16',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00"
);
const params = {
"include=members-count": "16",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00?include%3Dmembers-count=16" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "5a687460-c16a-11ee-ba3e-9104171aa8e9",
"name": {
"en": "autem"
},
"description": {
"en": "Alice, whose thoughts were still running on the ground near the house down!' said the Mock Turtle to sing \"Twinkle, twinkle, little bat! How I wonder what they said. The executioner's argument was."
},
"parent_id": "5b5fda90-c16a-11ee-99bf-093f76e866cd",
"_key": null
}
}
Received response:
Request failed with error:
Update Organization
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'sunt',
'company_code' => 'enim',
'address' => 'mollitia',
'city' => 'esse',
'vat' => 'quia',
'domains' => [
'beatae',
],
'slug' => 'eaque',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "sunt",
"company_code": "enim",
"address": "mollitia",
"city": "esse",
"vat": "quia",
"domains": [
"beatae"
],
"slug": "eaque"
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"sunt\",
\"company_code\": \"enim\",
\"address\": \"mollitia\",
\"city\": \"esse\",
\"vat\": \"quia\",
\"domains\": [
\"beatae\"
],
\"slug\": \"eaque\"
}"
Example response (200):
{
"data": {
"organization_id": "5b677220-c16a-11ee-ad57-87bf15a2b503",
"name": {
"en": "asperiores"
},
"description": {
"en": "Gryphon answered, very nearly getting up and saying, 'Thank you, it's a very decided tone: 'tell her something worth hearing. For some minutes the whole place around her became alive with the Queen."
},
"parent_id": "5c5d36d0-c16a-11ee-88fe-b375fd4b45e9",
"_key": null
}
}
Received response:
Request failed with error:
Exists by slug
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/exists',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/exists"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/exists" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (500):
Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
{
"message": "Server Error"
}
Received response:
Request failed with error:
List Organization Users
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/users',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'filter[similarly_ranked]'=> '1',
'filter[active]'=> '1',
'filter[search]'=> 'John',
'include'=> 'organization_units',
'sorts'=> 'rank,-reputation',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/users"
);
const params = {
"filter[similarly_ranked]": "1",
"filter[active]": "1",
"filter[search]": "John",
"include": "organization_units",
"sorts": "rank,-reputation",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/user/organizations/18832260-c7b3-11ed-a964-87702eeadd00/users?filter%5Bsimilarly_ranked%5D=1&filter%5Bactive%5D=1&filter%5Bsearch%5D=John&include=organization_units&sorts=rank%2C-reputation" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"name": "Icie",
"surname": "Monahan",
"email": "alfonso73@example.org",
"phone": "(540) 360-8025",
"email_verified_at": "1974-11-01T11:07:18.000000Z",
"_key": null
},
{
"name": "Savannah",
"surname": "Hickle",
"email": "doyle.jerald@example.org",
"phone": "(947) 296-1035",
"email_verified_at": "1972-10-05T04:47:36.000000Z",
"_key": null
}
]
}
Received response:
Request failed with error:
Organization domain exists by name
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/user/organization-domains/318695e0-03a2-11ee-ad7c-115d06207d80/exists',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/user/organization-domains/318695e0-03a2-11ee-ad7c-115d06207d80/exists"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/user/organization-domains/318695e0-03a2-11ee-ad7c-115d06207d80/exists" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (500):
Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
{
"message": "Server Error"
}
Received response:
Request failed with error:
Open
World
List Countries
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/world/countries',
[
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'states,cities,timezones,currency',
'filter[name]'=> 'Estonia',
'filter[phone_code]'=> '440',
'filter[region]'=> 'Europe',
'filter[subregion]'=> 'Southern Europe',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/world/countries"
);
const params = {
"include": "states,cities,timezones,currency",
"filter[name]": "Estonia",
"filter[phone_code]": "440",
"filter[region]": "Europe",
"filter[subregion]": "Southern Europe",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/world/countries?include=states%2Ccities%2Ctimezones%2Ccurrency&filter%5Bname%5D=Estonia&filter%5Bphone_code%5D=440&filter%5Bregion%5D=Europe&filter%5Bsubregion%5D=Southern+Europe" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"iso2": "TL",
"name": "Sao Tome and Principe",
"status": 1,
"phone_code": 903,
"iso3": "LBY",
"region": "ex",
"subregion": "sed",
"_key": null
},
{
"iso2": "GW",
"name": "Trinidad and Tobago",
"status": 1,
"phone_code": 396,
"iso3": "NFK",
"region": "dicta",
"subregion": "similique",
"_key": null
}
]
}
Received response:
Request failed with error:
View Country
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/world/countries/consectetur',
[
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'states,cities,timezones,currency',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/world/countries/consectetur"
);
const params = {
"include": "states,cities,timezones,currency",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/world/countries/consectetur?include=states%2Ccities%2Ctimezones%2Ccurrency" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"iso2": "AM",
"name": "American Samoa",
"status": 1,
"phone_code": 558,
"iso3": "MOZ",
"region": "voluptas",
"subregion": "iste",
"_key": null
}
}
Received response:
Request failed with error:
List States
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/world/states',
[
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'country,cities',
'filter[name]'=> 'Bamyan',
'filter[country_code]'=> 'ES',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/world/states"
);
const params = {
"include": "country,cities",
"filter[name]": "Bamyan",
"filter[country_code]": "ES",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/world/states?include=country%2Ccities&filter%5Bname%5D=Bamyan&filter%5Bcountry_code%5D=ES" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"country_id": 2942,
"name": "BSD",
"country_code": "FK",
"_key": null
},
{
"country_id": 2943,
"name": "ETB",
"country_code": "AL",
"_key": null
}
]
}
Received response:
Request failed with error:
View State
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/world/states/eaque',
[
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'country,cities',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/world/states/eaque"
);
const params = {
"include": "country,cities",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/world/states/eaque?include=country%2Ccities" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"country_id": 2944,
"name": "MZN",
"country_code": "MX",
"_key": null
}
}
Received response:
Request failed with error:
List Cities
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/world/cities',
[
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'country,state',
'filter[name]'=> 'Burrel',
'filter[country_code]'=> 'ES',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/world/cities"
);
const params = {
"include": "country,state",
"filter[name]": "Burrel",
"filter[country_code]": "ES",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/world/cities?include=country%2Cstate&filter%5Bname%5D=Burrel&filter%5Bcountry_code%5D=ES" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"country_id": 2945,
"state_id": 5502,
"name": "RUB",
"country_code": "GT",
"_key": null
},
{
"country_id": 2947,
"state_id": 5503,
"name": "ERN",
"country_code": "HT",
"_key": null
}
]
}
Received response:
Request failed with error:
View City
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/world/cities/aut',
[
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'country,state',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/world/cities/aut"
);
const params = {
"include": "country,state",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/world/cities/aut?include=country%2Cstate" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"country_id": 2949,
"state_id": 5504,
"name": "LKR",
"country_code": "BW",
"_key": null
}
}
Received response:
Request failed with error:
List Timezones
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/world/timezones',
[
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'filter[name]'=> 'Europe/Tirane',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/world/timezones"
);
const params = {
"filter[name]": "Europe/Tirane",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/world/timezones?filter%5Bname%5D=Europe%2FTirane" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"country_id": 2951,
"name": "BBD",
"_key": null
},
{
"country_id": 2952,
"name": "JMD",
"_key": null
}
]
}
Received response:
Request failed with error:
List Currencies
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/world/currencies',
[
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'filter[name]'=> 'Europe/Tirane',
'filter[code]'=> 'Europe/Tirane',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/world/currencies"
);
const params = {
"filter[name]": "Europe/Tirane",
"filter[code]": "Europe/Tirane",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/world/currencies?filter%5Bname%5D=Europe%2FTirane&filter%5Bcode%5D=Europe%2FTirane" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"country_id": 2953,
"name": "quos",
"code": "BIF",
"precision": 2,
"symbol": "€",
"symbol_native": "€",
"symbol_first": "1",
"decimal_mark": ".",
"thousands_separator": ",",
"_key": null
},
{
"country_id": 2954,
"name": "officiis",
"code": "SHP",
"precision": 2,
"symbol": "€",
"symbol_native": "€",
"symbol_first": "1",
"decimal_mark": ".",
"thousands_separator": ",",
"_key": null
}
]
}
Received response:
Request failed with error:
List Languages
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/world/languages',
[
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'filter[code]'=> 'es',
'filter[name]'=> 'Aymara',
'filter[name_native]'=> 'aymar aru',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/world/languages"
);
const params = {
"filter[code]": "es",
"filter[name]": "Aymara",
"filter[name_native]": "aymar aru",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/world/languages?filter%5Bcode%5D=es&filter%5Bname%5D=Aymara&filter%5Bname_native%5D=aymar+aru" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"code": "yo",
"name": "excepturi",
"name_native": "laborum",
"dir": "ltr",
"_key": null
},
{
"code": "ka",
"name": "qui",
"name_native": "non",
"dir": "ltr",
"_key": null
}
]
}
Received response:
Request failed with error:
Public Business Process Models
View Business Model
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/public-business-process-models/nam',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include=category,diagrams'=> 'quae',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/public-business-process-models/nam"
);
const params = {
"include=category,diagrams": "quae",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/public-business-process-models/nam?include%3Dcategory%2Cdiagrams=quae" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"owner_id": "97b732b0-c169-11ee-aebe-edf182d16795",
"organization_id": "983154f0-c169-11ee-a7f2-5794f7bb945b",
"category_id": 390045,
"business_process_id": 31705,
"name": "maxime",
"_lft": 1747651854,
"_rgt": 1009143906,
"summary": "Alice, 'a great girl like you,' (she might well say this), 'to go on till you come and join the dance. '\"What matters it how far we go?\" his scaly friend replied. \"There is another shore, you know.",
"type": "process",
"_key": null
}
}
Received response:
Request failed with error:
View Business Process Submission Form
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/form',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/form"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/form" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
[],
[]
]
}
Example response (200):
{
"data": {
"some_string_property": {
"attribute": {
"reference": "some_string_property",
"engine_reference": "someStringProperty",
"type": "string",
"label": "Some String Property",
"value": "122",
},
"some_integer_property": {
"attribute": {
"reference": "some_integer_property",
"engine_reference": "someIntegerProperty",
"type": "integer",
"label": "Some Integer Property",
"value": 122,
},
"some_float_property": {
"attribute": {
"reference": "some_float_property",
"engine_reference": "someFloatProperty",
"type": "float",
"label": "Some Float Property",
"value": 122.0
},
"some_boolean_property": {
"attribute": {
"reference": "some_boolean_property",
"engine_reference": "someBooleanProperty",
"type": "boolean",
"label": "Some Boolean Property",
"value": true
},
"some_date_property": {
"attribute": {
"reference": "some_date_property",
"engine_reference": "someDateProperty",
"type": "date",
"label": "Some Date Property",
"value": "2035-01-01"
},
"some_date_time_property": {
"attribute": {
"reference": "some_date_time_property",
"engine_reference": "someDateTimeProperty",
"type": "date_time",
"label": "Some Date Time Property",
"value": "2035-01-01T00:00:00Z"
},
}
}
Received response:
Request failed with error:
Start Business Process
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/start',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'external_execution_reference' => 'quis',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/start"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"external_execution_reference": "quis"
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/public-business-process-models/01f68d00-40da-11ee-9df1-41abd31f433d/start" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"external_execution_reference\": \"quis\"
}"
Example response (200):
{
"data": {
"business_model_id": "9ba2a750-c169-11ee-961e-ddcc110492aa",
"version": 500,
"versions": [],
"_key": null
}
}
Received response:
Request failed with error:
Organization
Organization Units
List Organization Units
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/organization-units',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'filter[root]=1'=> 'sint',
'filter[trashed]=only'=> 'sint',
'filter[search]=arb'=> 'rerum',
'include=children'=> 'corporis',
'include=organization'=> 'tempora',
'include=business-models'=> 'ea',
'include=members-count'=> '20',
'include=models-count'=> '13',
'include=business-models-count'=> '17',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/organization-units"
);
const params = {
"filter[root]=1": "sint",
"filter[trashed]=only": "sint",
"filter[search]=arb": "rerum",
"include=children": "corporis",
"include=organization": "tempora",
"include=business-models": "ea",
"include=members-count": "20",
"include=models-count": "13",
"include=business-models-count": "17",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/organization-units?filter%5Broot%5D%3D1=sint&filter%5Btrashed%5D%3Donly=sint&filter%5Bsearch%5D%3Darb=rerum&include%3Dchildren=corporis&include%3Dorganization=tempora&include%3Dbusiness-models=ea&include%3Dmembers-count=20&include%3Dmodels-count=13&include%3Dbusiness-models-count=17" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"organization_id": "4918cfa0-c16a-11ee-b778-5bf1618c5a06",
"name": {
"en": "nulla"
},
"description": {
"en": "Silence all round, if you could keep it to the Dormouse, after thinking a minute or two the Caterpillar angrily, rearing itself upright as it went. So she was as much as she could do to ask: perhaps."
},
"parent_id": "4a0c1ca0-c16a-11ee-b2db-31f820d6125a",
"_key": null
},
{
"organization_id": "4a0e2360-c16a-11ee-b5f4-f7e6db02471b",
"name": {
"en": "corporis"
},
"description": {
"en": "Gryphon interrupted in a bit.' 'Perhaps it hasn't one,' Alice ventured to remark. 'Tut, tut, child!' said the cook. 'Treacle,' said a whiting to a mouse: she had a VERY unpleasant state of mind, she."
},
"parent_id": "4afb5650-c16a-11ee-a727-0d80ffcc86ea",
"_key": null
}
]
}
Received response:
Request failed with error:
Create Organization Unit
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/organization-units',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'kjuluwdudgfuwsghbdbfenhapybgehdsemtzyfdrkxohmkyhsmqxr',
'description' => 'Voluptatem nulla et quidem.',
'parent_id' => 'adipisci',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/organization-units"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "kjuluwdudgfuwsghbdbfenhapybgehdsemtzyfdrkxohmkyhsmqxr",
"description": "Voluptatem nulla et quidem.",
"parent_id": "adipisci"
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/organization-units" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"kjuluwdudgfuwsghbdbfenhapybgehdsemtzyfdrkxohmkyhsmqxr\",
\"description\": \"Voluptatem nulla et quidem.\",
\"parent_id\": \"adipisci\"
}"
Example response (200):
{
"data": {
"organization_id": "4b04e130-c16a-11ee-b8b3-2514889351d2",
"name": {
"en": "blanditiis"
},
"description": {
"en": "Alice; 'I might as well say that \"I see what would happen next. The first witness was the only one who had been broken to pieces. 'Please, then,' said the last few minutes she heard the Rabbit."
},
"parent_id": "4bf66c60-c16a-11ee-bab2-256d98b7ded3",
"_key": null
}
}
Received response:
Request failed with error:
View Organization Unit
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include=children'=> 'qui',
'include=organization'=> 'maiores',
'include=members-count'=> '12',
'include=models-count'=> '15',
],
'json' => [
'user_ids' => [
'nam',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1"
);
const params = {
"include=children": "qui",
"include=organization": "maiores",
"include=members-count": "12",
"include=models-count": "15",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"user_ids": [
"nam"
]
};
fetch(url, {
method: "GET",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1?include%3Dchildren=qui&include%3Dorganization=maiores&include%3Dmembers-count=12&include%3Dmodels-count=15" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"user_ids\": [
\"nam\"
]
}"
Example response (200):
{
"data": {
"organization_id": "4bfe5690-c16a-11ee-aaf2-17da4c7e36bb",
"name": {
"en": "qui"
},
"description": {
"en": "Alice looked at the great hall, with the Duchess, 'chop off her head!' about once in her life, and had just succeeded in bringing herself down to nine inches high. CHAPTER VI. Pig and Pepper For a."
},
"parent_id": "4cefa2a0-c16a-11ee-9240-27d28d65a931",
"_key": null
}
}
Received response:
Request failed with error:
Update Organization Unit
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'uvwhiirugwwkotntweodhtcubjeztxhqnhppgejgthwetqkxbxajworhpgqbycxeyphmqnjtvkc',
'description' => 'Placeat facere repellendus unde assumenda.',
'user_ids' => [
'veritatis',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "uvwhiirugwwkotntweodhtcubjeztxhqnhppgejgthwetqkxbxajworhpgqbycxeyphmqnjtvkc",
"description": "Placeat facere repellendus unde assumenda.",
"user_ids": [
"veritatis"
]
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"uvwhiirugwwkotntweodhtcubjeztxhqnhppgejgthwetqkxbxajworhpgqbycxeyphmqnjtvkc\",
\"description\": \"Placeat facere repellendus unde assumenda.\",
\"user_ids\": [
\"veritatis\"
]
}"
Example response (200):
{
"data": {
"organization_id": "4cf6fde0-c16a-11ee-9969-f7564ca739e9",
"name": {
"en": "error"
},
"description": {
"en": "I'm mad. You're mad.' 'How do you know why it's called a whiting?' 'I never saw one, or heard of uglifying!' it exclaimed. 'You know what \"it\" means well enough, when I get SOMEWHERE,' Alice added."
},
"parent_id": "4df555a0-c16a-11ee-ae9f-970403924f2e",
"_key": null
}
}
Received response:
Request failed with error:
Delete Organization Unit
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "4dfc7640-c16a-11ee-8b19-71b15f9dae1b",
"name": {
"en": "non"
},
"description": {
"en": "Rabbit say to itself, half to herself, 'whenever I eat one of the thing yourself, some winter day, I will just explain to you to leave it behind?' She said the sage, as he came, 'Oh! the Duchess, as."
},
"parent_id": "4f23a8c0-c16a-11ee-ad20-9f52b743cf1d",
"_key": null
}
}
Received response:
Request failed with error:
Assign Users to Organization Unit
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/assign',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'ids' => [
'ut',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/assign"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"ids": [
"ut"
]
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/assign" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"ids\": [
\"ut\"
]
}"
Example response (200):
{
"data": {
"organization_id": "4f2b51c0-c16a-11ee-abb8-0583f891a3a9",
"name": {
"en": "quia"
},
"description": {
"en": "Canterbury, found it so yet,' said the Gryphon. 'Well, I never knew whether it was a little scream of laughter. 'Oh, hush!' the Rabbit say, 'A barrowful of WHAT?' thought Alice; 'but a grin without."
},
"parent_id": "502bf660-c16a-11ee-a756-857bfc2ed002",
"_key": null
}
}
Received response:
Request failed with error:
Unassign Users from Organization Unit
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/unassign',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'ids' => [
'qui',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/unassign"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"ids": [
"qui"
]
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/unassign" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"ids\": [
\"qui\"
]
}"
Example response (200):
{
"data": {
"organization_id": "5033c940-c16a-11ee-a9fb-b93dbba5f041",
"name": {
"en": "nihil"
},
"description": {
"en": "What would become of you? I gave her answer. 'They're done with a shiver. 'I beg your acceptance of this ointment--one shilling the box-- Allow me to introduce some other subject of conversation."
},
"parent_id": "512bba20-c16a-11ee-b600-69817a9e7f84",
"_key": null
}
}
Received response:
Request failed with error:
Restore Organization Unit
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/restore',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/restore"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "POST",
headers,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/organization-units/0243bf20-312c-11ee-88bb-8bf7d39fb7e1/restore" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "51376420-c16a-11ee-bba2-fb676d46db80",
"name": {
"en": "dicta"
},
"description": {
"en": "Rome--no, THAT'S all wrong, I'm certain! I must have been was not going to shrink any further: she felt that it led into the book her sister on the ground as she could, and waited to see what was on."
},
"parent_id": "5237ba30-c16a-11ee-9b40-594d267a166b",
"_key": null
}
}
Received response:
Request failed with error:
Billing
List Subscriptions
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/billing/subscriptions',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/billing/subscriptions"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/billing/subscriptions" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"id": "qui",
"createdAt": null,
"startAt": null,
"currentPeriodEndAt": null,
"latestInvoiceId": null,
"status": "modi",
"name": null
},
{
"id": "minima",
"createdAt": null,
"startAt": null,
"currentPeriodEndAt": null,
"latestInvoiceId": null,
"status": "et",
"name": null
}
]
}
Received response:
Request failed with error:
List Payments
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/billing/payments',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/billing/payments"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/billing/payments" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"id": "deserunt",
"amountPaid": null,
"pdf": null,
"paidAt": null,
"status": "aspernatur",
"subscriptionId": null,
"total": 343428365
},
{
"id": "a",
"amountPaid": null,
"pdf": null,
"paidAt": null,
"status": "alias",
"subscriptionId": null,
"total": 2644172
}
]
}
Received response:
Request failed with error:
Installation
List Environments
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/environments',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environments"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/environments" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"engine_id": "428a0500-c16a-11ee-88d2-9be6cf6dd0d2",
"engine_reference": "ce087331-fd72-35bb-ba9f-1d0a8bcadb8d",
"production": false,
"name": "consequuntur",
"auth_token": "8b880045-fc29-3925-be7f-9ad8dc40e3cb",
"_key": null
},
{
"engine_id": "430a5ef0-c16a-11ee-997b-0d2d901ade72",
"engine_reference": "737610f9-7b15-3512-ab40-a97f66321b74",
"production": true,
"name": "optio",
"auth_token": "eed93790-7379-3e85-ae77-30c3522d7ad9",
"_key": null
}
]
}
Received response:
Request failed with error:
Create Environment
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/environments',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'libero',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environments"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "libero"
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/environments" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"libero\"
}"
Example response (200):
{
"data": {
"organization_id": "430fa290-c16a-11ee-ae6a-a9f5f65f76b7",
"slug": "neque-enim-exercitationem-totam",
"name": "voluptas",
"description": "Mock Turtle's heavy sobs. Lastly, she pictured to herself 'It's the stupidest tea-party I ever saw one that size? Why, it fills the whole thing very absurd, but they were mine before. If I or she.",
"_lft": 1849150049,
"_rgt": 544918715,
"parent_id": 394130,
"prefix": ".",
"_key": null
}
}
Received response:
Request failed with error:
Delete Environments
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/environments',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'ids' => [
'fugit',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environments"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"ids": [
"fugit"
]
};
fetch(url, {
method: "DELETE",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/environments" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"ids\": [
\"fugit\"
]
}"
Example response (200):
{
"data": [
{
"organization_id": "43fff260-c16a-11ee-8927-31934de3e50b",
"slug": "et-sit-nisi-sed-repellat-quae-exercitationem",
"name": "atque",
"description": "The Gryphon sat up and ran off, thinking while she remembered that she might as well wait, as she leant against a buttercup to rest herself, and shouted out, 'You'd better not do that again!' which.",
"_lft": 1419196541,
"_rgt": 1809564431,
"parent_id": 394155,
"prefix": ".",
"_key": null
},
{
"organization_id": "44fed420-c16a-11ee-8821-9f5ee5b345c4",
"slug": "voluptatem-quas-in-fugiat-adipisci-earum-optio-praesentium",
"name": "cum",
"description": "Alice said to herself; 'I should think it would be worth the trouble of getting her hands on her spectacles, and began by taking the little golden key, and unlocking the door opened inwards, and.",
"_lft": 1812760603,
"_rgt": 633582351,
"parent_id": 394180,
"prefix": ".",
"_key": null
}
]
}
Received response:
Request failed with error:
List Engines
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/engines',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/engines"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/engines" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"name": "quidem",
"bridge": "camunda",
"_key": null
},
{
"name": "sed",
"bridge": "camunda",
"_key": null
}
]
}
Received response:
Request failed with error:
Create Engine
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/engines',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'vknrwbuzjcslefba',
'path' => 'lhcyrqbhjpowohpes',
'auth' => 'ozal',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/engines"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "vknrwbuzjcslefba",
"path": "lhcyrqbhjpowohpes",
"auth": "ozal"
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/engines" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"vknrwbuzjcslefba\",
\"path\": \"lhcyrqbhjpowohpes\",
\"auth\": \"ozal\"
}"
Example response (200):
{
"data": {
"name": "placeat",
"bridge": "camunda",
"_key": null
}
}
Received response:
Request failed with error:
View Engine
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/engines/unde',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/engines/unde"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/engines/unde" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"name": "et",
"bridge": "camunda",
"_key": null
}
}
Received response:
Request failed with error:
Update Engine
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/engines/minima',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'qryqfqqztzzcl',
'path' => 'nkliukxyvirzqyiaq',
'auth' => 'etc',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/engines/minima"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "qryqfqqztzzcl",
"path": "nkliukxyvirzqyiaq",
"auth": "etc"
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/engines/minima" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"qryqfqqztzzcl\",
\"path\": \"nkliukxyvirzqyiaq\",
\"auth\": \"etc\"
}"
Example response (200):
{
"data": {
"name": "optio",
"bridge": "camunda",
"_key": null
}
}
Received response:
Request failed with error:
Delete Engine
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/engines/consequatur',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/engines/consequatur"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/engines/consequatur" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"name": "ut",
"bridge": "camunda",
"_key": null
}
}
Received response:
Request failed with error:
Classification
List Categories
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/categories',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'filter[root]'=> '1',
'filter[siblings]'=> '145',
'filter[autocomplete]'=> 'tes',
'filter[search]'=> 'tes',
'include'=> 'children,business-models,business-models-count,business-models.comments-count,business-models.owner,business-models.latest-diagram',
'filter[search-business-models]'=> 'Some model',
'filter[organization-units][0]'=> 'optio',
'sort'=> 'name,-created_at,-updated_at Sorting example',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/categories"
);
const params = {
"filter[root]": "1",
"filter[siblings]": "145",
"filter[autocomplete]": "tes",
"filter[search]": "tes",
"include": "children,business-models,business-models-count,business-models.comments-count,business-models.owner,business-models.latest-diagram",
"filter[search-business-models]": "Some model",
"filter[organization-units][0]": "optio",
"sort": "name,-created_at,-updated_at Sorting example",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/categories?filter%5Broot%5D=1&filter%5Bsiblings%5D=145&filter%5Bautocomplete%5D=tes&filter%5Bsearch%5D=tes&include=children%2Cbusiness-models%2Cbusiness-models-count%2Cbusiness-models.comments-count%2Cbusiness-models.owner%2Cbusiness-models.latest-diagram&filter%5Bsearch-business-models%5D=Some+model&filter%5Borganization-units%5D[]=optio&sort=name%2C-created_at%2C-updated_at+Sorting+example" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"organization_id": "f70267d0-c169-11ee-ae8b-6547b56b87d3",
"slug": "expedita-expedita-libero-sunt-tempora-sapiente",
"name": "et",
"description": "And in she went. Once more she found that her neck would bend about easily in any direction, like a snout than a real nose; also its eyes by this time, and was just beginning to see the Mock Turtle.",
"_lft": 649327519,
"_rgt": 1891635682,
"parent_id": 392322,
"prefix": ".",
"_key": null
},
{
"organization_id": "f7e1c670-c169-11ee-8cb5-4f74a80fe282",
"slug": "amet-consequatur-ut-iste-aperiam",
"name": "est",
"description": "Alice's first thought was that you had been anxiously looking across the garden, and marked, with one finger, as he fumbled over the verses to himself: '\"WE KNOW IT TO BE TRUE--\" that's the jury.",
"_lft": 584296302,
"_rgt": 887632511,
"parent_id": 392347,
"prefix": ".",
"_key": null
}
]
}
Received response:
Request failed with error:
Create Category
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/categories',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'btvmhkmmzusjhzxohuytenlstqwwoghlozsujpgbhlrmgynakcrigmzrolcgosjvjsghcsdoblesda',
'description' => 'Porro corrupti aut sint debitis sed.',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/categories"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "btvmhkmmzusjhzxohuytenlstqwwoghlozsujpgbhlrmgynakcrigmzrolcgosjvjsghcsdoblesda",
"description": "Porro corrupti aut sint debitis sed."
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/categories" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"btvmhkmmzusjhzxohuytenlstqwwoghlozsujpgbhlrmgynakcrigmzrolcgosjvjsghcsdoblesda\",
\"description\": \"Porro corrupti aut sint debitis sed.\"
}"
Example response (200):
{
"data": {
"organization_id": "f8df5930-c169-11ee-9399-e777e45e9f04",
"slug": "sunt-placeat-ut-natus-omnis-vel-veniam-ipsa",
"name": "mollitia",
"description": "Duchess sneezed occasionally; and as Alice could not be denied, so she went on, 'What's your name, child?' 'My name is Alice, so please your Majesty,' said Alice desperately: 'he's perfectly.",
"_lft": 476949212,
"_rgt": 305780223,
"parent_id": 392372,
"prefix": ".",
"_key": null
}
}
Received response:
Request failed with error:
View Category
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/categories/59',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/categories/59"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/categories/59" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "f9c12c40-c169-11ee-9b52-d94b0fbf56e2",
"slug": "est-nisi-numquam-dolor-qui-sed-voluptatum-officia",
"name": "nostrum",
"description": "I don't care which happens!' She ate a little shaking among the people near the right size again; and the blades of grass, but she felt unhappy. 'It was the White Rabbit, 'and that's the queerest.",
"_lft": 1172836414,
"_rgt": 1462194827,
"parent_id": 392397,
"prefix": ".",
"_key": null
}
}
Received response:
Request failed with error:
Update Category
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/categories/59',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'lqndbjrbqibzghdsxufqiujjunjnscqrqnntbnnmzftovezyskrfjldsrljvekkloalmurodxkr',
'description' => 'Ex excepturi quis quia iure explicabo suscipit.',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/categories/59"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "lqndbjrbqibzghdsxufqiujjunjnscqrqnntbnnmzftovezyskrfjldsrljvekkloalmurodxkr",
"description": "Ex excepturi quis quia iure explicabo suscipit."
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/categories/59" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"lqndbjrbqibzghdsxufqiujjunjnscqrqnntbnnmzftovezyskrfjldsrljvekkloalmurodxkr\",
\"description\": \"Ex excepturi quis quia iure explicabo suscipit.\"
}"
Example response (200):
{
"data": {
"organization_id": "faa80100-c169-11ee-9ac6-43e91805d9e5",
"slug": "odit-cupiditate-nostrum-nihil-enim-ratione",
"name": "et",
"description": "Bill,' she gave her one, they gave him two, You gave us three or more; They all made of solid glass; there was not easy to take out of their wits!' So she went on growing, and growing, and she could.",
"_lft": 999058261,
"_rgt": 1571223090,
"parent_id": 392422,
"prefix": ".",
"_key": null
}
}
Received response:
Request failed with error:
Delete Category
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/categories/59',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/categories/59"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/categories/59" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "fb91f960-c169-11ee-9d03-070edab07521",
"slug": "et-ullam-quaerat-consequatur-dolorem-assumenda",
"name": "totam",
"description": "They were indeed a queer-looking party that assembled on the twelfth?' Alice went on, half to itself, 'Oh dear! Oh dear! I'd nearly forgotten to ask.' 'It turned into a line along the course, here.",
"_lft": 1300978262,
"_rgt": 473905996,
"parent_id": 392447,
"prefix": ".",
"_key": null
}
}
Received response:
Request failed with error:
List Tags
requires authentication
Create Tag
requires authentication
View Tag
requires authentication
Update Tag
requires authentication
Delete Tag
requires authentication
Collaboration
View Share
View Member Invitation
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd',
[
'headers' => [
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd"
);
const headers = {
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "fe635380-c169-11ee-acc2-b162fc812209",
"email": "nmetz@example.org",
"type": {},
"context": null,
"user_id": "fedd1760-c169-11ee-afc9-a53d3589ae2f",
"expired_at": "2005-03-27T02:36:54.000000Z",
"active": false,
"_key": null
}
}
Received response:
Request failed with error:
Delete Member Invitation
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "ff515040-c169-11ee-b34c-cb2d2019ebe9",
"email": "dexter15@example.net",
"type": {},
"context": null,
"user_id": "ffc4c4a0-c169-11ee-bcf1-9f51f3055c75",
"expired_at": "2020-01-26T11:40:28.000000Z",
"active": false,
"_key": null
}
}
Received response:
Request failed with error:
Accept Member Invitation
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd/accept',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd/accept"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "POST",
headers,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/invitations/0002f8e0-a090-11ed-85cb-c7881bdeb8dd/accept" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "003b5d90-c16a-11ee-a85c-4dac33f377c6",
"email": "clemens41@example.org",
"type": {},
"context": null,
"user_id": "00b68680-c16a-11ee-a8ec-83ea5ccd92ea",
"expired_at": "1970-10-04T15:20:35.000000Z",
"active": false,
"_key": null
}
}
Received response:
Request failed with error:
Delete Share
requires authentication
List Invitations
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/invitations',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'filter[active]'=> '1',
'filter[accepted]'=> '1',
'filter[expired]'=> '1',
'filter[search]'=> 'lorem',
'sort'=> '-created_at',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/invitations"
);
const params = {
"filter[active]": "1",
"filter[accepted]": "1",
"filter[expired]": "1",
"filter[search]": "lorem",
"sort": "-created_at",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/invitations?filter%5Bactive%5D=1&filter%5Baccepted%5D=1&filter%5Bexpired%5D=1&filter%5Bsearch%5D=lorem&sort=-created_at" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"organization_id": "030061c0-c16a-11ee-9969-b3c97b3beac9",
"email": "unader@example.net",
"type": {},
"context": null,
"user_id": "0375a8b0-c16a-11ee-8ad9-d73952e1d846",
"expired_at": "2016-03-01T09:58:01.000000Z",
"active": false,
"_key": null
},
{
"organization_id": "03e5fb90-c16a-11ee-ac9a-c1e54f4a1a0c",
"email": "mraz.garret@example.org",
"type": {},
"context": null,
"user_id": "045fdeb0-c16a-11ee-9e8e-fd06879a8692",
"expired_at": "1994-05-15T09:13:33.000000Z",
"active": false,
"_key": null
}
]
}
Received response:
Request failed with error:
Invite Members
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/invitations',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'emails' => [
'jose57@example.com',
],
'type' => 'generic',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/invitations"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"emails": [
"jose57@example.com"
],
"type": "generic"
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/invitations" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"emails\": [
\"jose57@example.com\"
],
\"type\": \"generic\"
}"
Example response (200):
{
"data": [
{
"organization_id": "04da6be0-c16a-11ee-9d50-afbe76725396",
"email": "dare.kris@example.com",
"type": {},
"context": null,
"user_id": "0555fbb0-c16a-11ee-ae3f-6b208a1b2442",
"expired_at": "2009-09-25T10:44:04.000000Z",
"active": false,
"_key": null
},
{
"organization_id": "05d6a550-c16a-11ee-9f9b-713704c7de7e",
"email": "gardner.beer@example.com",
"type": {},
"context": null,
"user_id": "065b0ff0-c16a-11ee-81a3-3dfd646e76ce",
"expired_at": "2010-04-27T08:34:39.000000Z",
"active": false,
"_key": null
}
]
}
Received response:
Request failed with error:
Business Models
List Business Models
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-models',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'owner,company,category,tags,comments-count,tags-count,diagrams',
'filter[with-any-tags]'=> 'test-tag,another-test-tag',
'filter[without-any-tags]'=> '1',
'filter[autocomplete]'=> 'tes',
'filter[search]'=> 'tes',
'filter[categories]'=> '1,2',
'filter[type]'=> 'eos',
'filter[uncategorized]'=> '1',
'filter[subscribable]'=> '1',
'filter[manual]'=> '1',
'filter[organization-units][0]'=> 'assumenda',
'filter[without-any-organization-units]'=> '1',
'filter[production]'=> '1',
'sort'=> 'name,-created_at,-updated_at',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-models"
);
const params = {
"include": "owner,company,category,tags,comments-count,tags-count,diagrams",
"filter[with-any-tags]": "test-tag,another-test-tag",
"filter[without-any-tags]": "1",
"filter[autocomplete]": "tes",
"filter[search]": "tes",
"filter[categories]": "1,2",
"filter[type]": "eos",
"filter[uncategorized]": "1",
"filter[subscribable]": "1",
"filter[manual]": "1",
"filter[organization-units][0]": "assumenda",
"filter[without-any-organization-units]": "1",
"filter[production]": "1",
"sort": "name,-created_at,-updated_at",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-models?include=owner%2Ccompany%2Ccategory%2Ctags%2Ccomments-count%2Ctags-count%2Cdiagrams&filter%5Bwith-any-tags%5D=test-tag%2Canother-test-tag&filter%5Bwithout-any-tags%5D=1&filter%5Bautocomplete%5D=tes&filter%5Bsearch%5D=tes&filter%5Bcategories%5D=1%2C2&filter%5Btype%5D=eos&filter%5Buncategorized%5D=1&filter%5Bsubscribable%5D=1&filter%5Bmanual%5D=1&filter%5Borganization-units%5D[]=assumenda&filter%5Bwithout-any-organization-units%5D=1&filter%5Bproduction%5D=1&sort=name%2C-created_at%2C-updated_at" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"owner_id": "9bbca9e0-c169-11ee-8a7f-d1724d7e6846",
"organization_id": "9c370920-c169-11ee-8bf4-4fb13c07d927",
"category_id": 390145,
"business_process_id": 31723,
"name": "accusamus",
"_lft": 1113828305,
"_rgt": 1828288328,
"summary": "All on a three-legged stool in the schoolroom, and though this was not quite like the three gardeners, oblong and flat, with their heads down! I am now? That'll be a queer thing, to be almost out of.",
"type": "process",
"_key": null
},
{
"owner_id": "9d9e34f0-c169-11ee-bcf8-f981a728b7d8",
"organization_id": "9e136100-c169-11ee-b78c-3b10d661b0e2",
"category_id": 390195,
"business_process_id": 31732,
"name": "possimus",
"_lft": 1514326361,
"_rgt": 1278883080,
"summary": "Alice. 'Reeling and Writhing, of course, I meant,' the King said to herself, 'whenever I eat or drink under the sea--' ('I haven't,' said Alice)--'and perhaps you haven't found it made Alice quite.",
"type": "process",
"_key": null
}
]
}
Received response:
Request failed with error:
Create Business Model
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/business-models',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'jfscfjp',
'type' => 'process',
'summary' => 'deleniti',
'organization_unit_ids' => [
'omnis',
],
'tag_values' => [
'quae',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-models"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "jfscfjp",
"type": "process",
"summary": "deleniti",
"organization_unit_ids": [
"omnis"
],
"tag_values": [
"quae"
]
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/business-models" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"jfscfjp\",
\"type\": \"process\",
\"summary\": \"deleniti\",
\"organization_unit_ids\": [
\"omnis\"
],
\"tag_values\": [
\"quae\"
]
}"
Example response (200):
{
"data": {
"owner_id": "9fa59920-c169-11ee-99bd-bb702690efb8",
"organization_id": "a0122b00-c169-11ee-89bb-1354f994fff7",
"category_id": 390245,
"business_process_id": 31741,
"name": "commodi",
"_lft": 983784227,
"_rgt": 1463907613,
"summary": "Alice was rather doubtful whether she ought not to be patted on the OUTSIDE.' He unfolded the paper as he spoke, and the Queen in a moment: she looked back once or twice, and shook itself. Then it.",
"type": "process",
"_key": null
}
}
Received response:
Request failed with error:
View Business Model
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-models/eveniet',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include=owner,organization,category,tags,comments-count,tags-count,diagrams'=> 'iure',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-models/eveniet"
);
const params = {
"include=owner,organization,category,tags,comments-count,tags-count,diagrams": "iure",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-models/eveniet?include%3Downer%2Corganization%2Ccategory%2Ctags%2Ccomments-count%2Ctags-count%2Cdiagrams=iure" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"owner_id": "a176b440-c169-11ee-98f1-f7dbcb3c4c94",
"organization_id": "a1ddfd70-c169-11ee-b28d-13386829da78",
"category_id": 390295,
"business_process_id": 31750,
"name": "tempora",
"_lft": 646616388,
"_rgt": 274610784,
"summary": "Alice thought), and it said in a hurry. 'No, I'll look first,' she said, 'and see whether it's marked \"poison\" or not'; for she felt that she tipped over the wig, (look at the top of his head. But.",
"type": "process",
"_key": null
}
}
Received response:
Request failed with error:
Update Business Model
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'khprffvobtewmltlmwuaeaaxtxzamskfzqxjkqhdzkxybshgizpngyuzfesheivfukwhswxjoslkufmwtaevocotxi',
'type' => 'process',
'summary' => 'amet',
'public' => true,
'organization_unit_ids' => [
'eveniet',
],
'tag_values' => [
'repellat',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "khprffvobtewmltlmwuaeaaxtxzamskfzqxjkqhdzkxybshgizpngyuzfesheivfukwhswxjoslkufmwtaevocotxi",
"type": "process",
"summary": "amet",
"public": true,
"organization_unit_ids": [
"eveniet"
],
"tag_values": [
"repellat"
]
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"khprffvobtewmltlmwuaeaaxtxzamskfzqxjkqhdzkxybshgizpngyuzfesheivfukwhswxjoslkufmwtaevocotxi\",
\"type\": \"process\",
\"summary\": \"amet\",
\"public\": true,
\"organization_unit_ids\": [
\"eveniet\"
],
\"tag_values\": [
\"repellat\"
]
}"
Example response (200):
{
"data": {
"owner_id": "a3443d60-c169-11ee-89d9-edecb82b07dd",
"organization_id": "a3b38770-c169-11ee-ab5a-1d5fcc29367c",
"category_id": 390345,
"business_process_id": 31759,
"name": "officiis",
"_lft": 2071252869,
"_rgt": 1233027753,
"summary": "I'm here! Digging for apples, indeed!' said the Hatter: 'but you could only hear whispers now and then nodded. 'It's no use denying it. I suppose I ought to be sure; but I THINK I can find it.' And.",
"type": "process",
"_key": null
}
}
Received response:
Request failed with error:
Delete Business Model
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/business-models/01f68d00-40da-11ee-9df1-41abd31f433d" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"owner_id": "a51ac820-c169-11ee-b397-318279772c48",
"organization_id": "a588d290-c169-11ee-9ccc-c70271c037d4",
"category_id": 390395,
"business_process_id": 31768,
"name": "iure",
"_lft": 1356956380,
"_rgt": 2015250325,
"summary": "Alice more boldly: 'you know you're growing too.' 'Yes, but I hadn't quite finished my tea when I sleep\" is the same solemn tone, 'For the Duchess. 'Everything's got a moral, if only you can find.",
"type": "process",
"_key": null
}
}
Received response:
Request failed with error:
Delete Business Models
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/business-models',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'ids' => [
'ut',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-models"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"ids": [
"ut"
]
};
fetch(url, {
method: "DELETE",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/business-models" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"ids\": [
\"ut\"
]
}"
Example response (200):
{
"data": {
"owner_id": "a6f0bd30-c169-11ee-bbd6-f92e01384bbf",
"organization_id": "a76441f0-c169-11ee-9503-134ea59dc35c",
"category_id": 390445,
"business_process_id": 31777,
"name": "repellat",
"_lft": 1706764788,
"_rgt": 455685209,
"summary": "YOU, and no more to do with this creature when I was thinking I should understand that better,' Alice said very humbly; 'I won't interrupt again. I dare say you never tasted an egg!' 'I HAVE tasted.",
"type": "process",
"_key": null
}
}
Received response:
Request failed with error:
List Business Model Diagrams
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-models/natus/revisions',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-models/natus/revisions"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-models/natus/revisions" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"business_model_id": "aa9d8990-c169-11ee-88c9-477465b7156e",
"version": 155,
"versions": [],
"_key": null
},
{
"business_model_id": "ac820f50-c169-11ee-aafc-5fd0d519a24f",
"version": 333,
"versions": [],
"_key": null
}
]
}
Received response:
Request failed with error:
Submit Business Model Diagram
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/business-models/et/revisions',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'multipart/form-data',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'multipart' => [
[
'name' => 'xml',
'contents' => 'et'
],
[
'name' => 'next_version',
'contents' => '4577.4609922'
],
[
'name' => 'prev_version',
'contents' => '33.02561'
],
[
'name' => 'snapshot',
'contents' => fopen('/tmp/phpCIKFnn', 'r')
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-models/et/revisions"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "multipart/form-data",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
const body = new FormData();
body.append('xml', 'et');
body.append('next_version', '4577.4609922');
body.append('prev_version', '33.02561');
body.append('snapshot', document.querySelector('input[name="snapshot"]').files[0]);
fetch(url, {
method: "POST",
headers,
body,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/business-models/et/revisions" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: multipart/form-data" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--form "xml=et" \
--form "next_version=4577.4609922" \
--form "prev_version=33.02561" \
--form "snapshot=@/tmp/phpCIKFnn"
Example response (200):
{
"data": {
"business_model_id": "ae6d2210-c169-11ee-9aec-5b64d41b76c7",
"version": 262,
"versions": [],
"_key": null
}
}
Received response:
Request failed with error:
View Business Model Diagram Revision
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-models/dolorem/revisions/nihil',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-models/dolorem/revisions/nihil"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-models/dolorem/revisions/nihil" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"business_model_id": "b07e06b0-c169-11ee-a57e-01cabccac725",
"version": 189,
"versions": [],
"_key": null
}
}
Received response:
Request failed with error:
Tag Business Model
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/business-models/eveniet/tag',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'tags' => [
'perferendis',
],
'type' => 'et',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-models/eveniet/tag"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"tags": [
"perferendis"
],
"type": "et"
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/business-models/eveniet/tag" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"tags\": [
\"perferendis\"
],
\"type\": \"et\"
}"
Example response (200):
{
"data": {
"name": {
"en": "sequi"
},
"_key": null
}
}
Received response:
Request failed with error:
Share Business Model
requires authentication
List Business Model Comments
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-models/eligendi/comments',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'commenter',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-models/eligendi/comments"
);
const params = {
"include": "commenter",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-models/eligendi/comments?include=commenter" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"parent_id": 2707,
"commentable_id": "b77ae9c0-c169-11ee-886b-9f22a847cc2f",
"commenter_id": "b7873d30-c169-11ee-9075-0114c66b325f",
"commentable_type": "App\\Models\\BusinessBaseModel",
"comment": "Cheshire cat,' said the Duchess. An invitation from the change: and Alice could not stand, and she had nibbled some more bread-and-butter--' 'But what am I to do?' said Alice. 'Of course you know.",
"status": 1,
"_key": null
},
{
"parent_id": 2708,
"commentable_id": "bdeafac0-c169-11ee-bda5-25f53a592f4a",
"commenter_id": "bdf78d90-c169-11ee-8dfc-fd5d4762d1d7",
"commentable_type": "App\\Models\\BusinessBaseModel",
"comment": "Mock Turtle. 'Very much indeed,' said Alice. 'Exactly so,' said the Hatter instead!' CHAPTER VII. A Mad Tea-Party There was no time she'd have everybody executed, all round. 'But she must have got.",
"status": 0,
"_key": null
}
]
}
Received response:
Request failed with error:
List Business Model Diagrams
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-model-diagrams',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-diagrams"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-model-diagrams" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"business_model_id": "c128fe60-c169-11ee-929a-21450a9745f2",
"version": 957,
"versions": [],
"_key": null
},
{
"business_model_id": "c3655ae0-c169-11ee-86f2-53517ee903f8",
"version": 672,
"versions": [],
"_key": null
}
]
}
Received response:
Request failed with error:
Create Business Model Diagram
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/business-model-diagrams',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'multipart/form-data',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'multipart' => [
[
'name' => 'xml',
'contents' => 'iste'
],
[
'name' => 'next_version',
'contents' => '134.6862'
],
[
'name' => 'prev_version',
'contents' => '469.183957679'
],
[
'name' => 'business_model_id',
'contents' => 'qui'
],
[
'name' => 'snapshot',
'contents' => fopen('/tmp/phpKMLAnM', 'r')
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-diagrams"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "multipart/form-data",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
const body = new FormData();
body.append('xml', 'iste');
body.append('next_version', '134.6862');
body.append('prev_version', '469.183957679');
body.append('business_model_id', 'qui');
body.append('snapshot', document.querySelector('input[name="snapshot"]').files[0]);
fetch(url, {
method: "POST",
headers,
body,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/business-model-diagrams" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: multipart/form-data" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--form "xml=iste" \
--form "next_version=134.6862" \
--form "prev_version=469.183957679" \
--form "business_model_id=qui" \
--form "snapshot=@/tmp/phpKMLAnM"
Example response (200):
{
"data": {
"business_model_id": "c57ac380-c169-11ee-8086-03e3a9d5dc11",
"version": 603,
"versions": [],
"_key": null
}
}
Received response:
Request failed with error:
View Business Model Diagram
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-model-diagrams/ratione',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-diagrams/ratione"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-model-diagrams/ratione" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"business_model_id": "c77d5270-c169-11ee-b4cf-c57441862bd9",
"version": 435,
"versions": [],
"_key": null
}
}
Received response:
Request failed with error:
Delete Business Model Diagram
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/business-model-diagrams/00305390-3793-11ee-afbb-cf67e78d05cc',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-diagrams/00305390-3793-11ee-afbb-cf67e78d05cc"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/business-model-diagrams/00305390-3793-11ee-afbb-cf67e78d05cc" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"business_model_id": "c9a2cca0-c169-11ee-99e5-31f34b785e34",
"version": 248,
"versions": [],
"_key": null
}
}
Received response:
Request failed with error:
Publish Business Model Diagram
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/business-model-diagrams/quibusdam/publish',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-diagrams/quibusdam/publish"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "POST",
headers,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/business-model-diagrams/quibusdam/publish" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
Example response (200):
{
"data": {
"business_model_id": "cbb65130-c169-11ee-b849-7b9b838b9fda",
"version": 612,
"versions": [],
"_key": null
}
}
Received response:
Request failed with error:
Download Business Model Diagram Snapshot
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-model-diagrams/error/snapshots/4',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-diagrams/error/snapshots/4"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-model-diagrams/error/snapshots/4" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"business_model_id": "cdc73db0-c169-11ee-b156-7da5e2e3cafa",
"version": 988,
"versions": [],
"_key": null
},
{
"business_model_id": "cfe515c0-c169-11ee-a777-0dfcf8ea5960",
"version": 923,
"versions": [],
"_key": null
}
]
}
Received response:
Request failed with error:
List Business Model Diagram Comments
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-model-diagrams/quisquam/comments',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'commenter',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-diagrams/quisquam/comments"
);
const params = {
"include": "commenter",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-model-diagrams/quisquam/comments?include=commenter" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"parent_id": 2709,
"commentable_id": "d4c70100-c169-11ee-8ede-a30d630583da",
"commenter_id": "d4d411b0-c169-11ee-88cb-151af6494e07",
"commentable_type": "App\\Models\\BusinessBaseModel",
"comment": "Dinah stop in the world she was as much right,' said the Hatter, it woke up again with a growl, And concluded the banquet--] 'What IS the same tone, exactly as if she had never before seen a good.",
"status": 0,
"_key": null
},
{
"parent_id": 2710,
"commentable_id": "da1a6380-c169-11ee-a43f-fbfd13c6699a",
"commenter_id": "da26a2b0-c169-11ee-914c-1398f534d3ca",
"commentable_type": "App\\Models\\BusinessBaseModel",
"comment": "I will just explain to you how the game was in a trembling voice, '--and I hadn't mentioned Dinah!' she said to herself, and shouted out, 'You'd better not talk!' said Five. 'I heard every word you.",
"status": 0,
"_key": null
}
]
}
Received response:
Request failed with error:
Create Business Model Diagram Comment
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/business-model-diagrams/explicabo/comments',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'comment' => 'aut',
'parent' => 15,
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-diagrams/explicabo/comments"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"comment": "aut",
"parent": 15
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/business-model-diagrams/explicabo/comments" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"comment\": \"aut\",
\"parent\": 15
}"
Example response (200):
{
"data": {
"parent_id": 2711,
"commentable_id": "df417560-c169-11ee-89ab-17f33e30cb14",
"commenter_id": "df4d9730-c169-11ee-9f64-41c3d23c3d56",
"commentable_type": "App\\Models\\BusinessBaseModel",
"comment": "As she said to Alice, and she tried the roots of trees, and I've tried hedges,' the Pigeon in a helpless sort of people live about here?' 'In THAT direction,' the Cat said, waving its right ear and.",
"status": 0,
"_key": null
}
}
Received response:
Request failed with error:
Delete Business Model Diagram Comment
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/business-model-diagrams/doloremque/comments/1',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-diagrams/doloremque/comments/1"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/business-model-diagrams/doloremque/comments/1" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"parent_id": 2712,
"commentable_id": "e4a0f250-c169-11ee-b04b-67cbf76a04c3",
"commenter_id": "e4ad4400-c169-11ee-b0bf-f9f208607f61",
"commentable_type": "App\\Models\\BusinessBaseModel",
"comment": "Knave of Hearts, who only bowed and smiled in reply. 'Please come back again, and the other bit. Her chin was pressed so closely against her foot, that there was nothing on it were white, but there.",
"status": 0,
"_key": null
}
}
Received response:
Request failed with error:
List Business Model Publications
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-model-publications',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'diagram,diagram.model',
'filter[business-model-diagram]'=> '5445fd-2454554-fddffd-5445',
'filter[manual]'=> '1',
'filter[eligible]'=> '1',
'filter[production]'=> '1',
'filter[type]'=> 'process',
'filter[latest]'=> '1',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-publications"
);
const params = {
"include": "diagram,diagram.model",
"filter[business-model-diagram]": "5445fd-2454554-fddffd-5445",
"filter[manual]": "1",
"filter[eligible]": "1",
"filter[production]": "1",
"filter[type]": "process",
"filter[latest]": "1",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-model-publications?include=diagram%2Cdiagram.model&filter%5Bbusiness-model-diagram%5D=5445fd-2454554-fddffd-5445&filter%5Bmanual%5D=1&filter%5Beligible%5D=1&filter%5Bproduction%5D=1&filter%5Btype%5D=process&filter%5Blatest%5D=1" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"business_model_diagram_id": "e7401a70-c169-11ee-9a43-8b857adc6f50",
"engine_deployment_reference": "f8c03421-9d4e-3d6f-ad35-bb48babb7ca9",
"engine_diagram_reference": "124004ce-e3fe-3f87-9b50-eb6ef85574b2",
"engine_model_reference": "Process_AccusamusEtFuga.",
"_key": null
},
{
"business_model_diagram_id": "e932d020-c169-11ee-8add-87e8d0c71c66",
"engine_deployment_reference": "447e9ef5-b191-31ee-b898-7d1966726d98",
"engine_diagram_reference": "6f493c78-18df-385f-8856-ed9350e2e905",
"engine_model_reference": "Process_AccusantiumEaque.",
"_key": null
}
]
}
Received response:
Request failed with error:
View Business Model Publication
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-model-publications/et',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-publications/et"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-model-publications/et" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"business_model_diagram_id": "eb1e4050-c169-11ee-b83d-9764a0d7b8fe",
"engine_deployment_reference": "b60df4e8-3e15-3e25-b318-ecd5a01e2683",
"engine_diagram_reference": "2b2c0ee0-d46b-3fa9-869f-7c04e246e3d0",
"engine_model_reference": "Process_PerspiciatisNisi.",
"_key": null
}
}
Received response:
Request failed with error:
List Business Model Exceptions
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-model-exceptions',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-exceptions"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-model-exceptions" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"organization_id": "eb27deb0-c169-11ee-b701-c748e1ca410f",
"source": {
"en": "delectus"
},
"solution": {
"en": "nostrum"
},
"consequences": {
"en": "commodi"
},
"incidence": "high",
"impact": "low",
"causative_organization_unit_id": "ebff43e0-c169-11ee-b864-73e3af0879f8",
"responsible_organization_unit_id": "ec793e60-c169-11ee-82ae-9d69de25c8de",
"incidence_options": [
"very_low",
"low",
"medium",
"high",
"very_high"
],
"impact_options": [
"none",
"low",
"medium",
"high"
],
"_key": null
},
{
"organization_id": "ec7a7740-c169-11ee-8947-67456e798a50",
"source": {
"en": "minus"
},
"solution": {
"en": "aut"
},
"consequences": {
"en": "fugiat"
},
"incidence": "low",
"impact": "low",
"causative_organization_unit_id": "ed6849e0-c169-11ee-8de7-117493b65c73",
"responsible_organization_unit_id": "edde6cb0-c169-11ee-b4fc-39973728344d",
"incidence_options": [
"very_low",
"low",
"medium",
"high",
"very_high"
],
"impact_options": [
"none",
"low",
"medium",
"high"
],
"_key": null
}
]
}
Received response:
Request failed with error:
View Business Model Exception
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-model-exceptions/fugiat',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-model-exceptions/fugiat"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-model-exceptions/fugiat" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "edeac420-c169-11ee-8d65-71e508b380b0",
"source": {
"en": "placeat"
},
"solution": {
"en": "et"
},
"consequences": {
"en": "impedit"
},
"incidence": "very_high",
"impact": "medium",
"causative_organization_unit_id": "eecbedd0-c169-11ee-9018-bf3009f7d1ed",
"responsible_organization_unit_id": "ef4d5e00-c169-11ee-b8cc-99e6884964fe",
"incidence_options": [
"very_low",
"low",
"medium",
"high",
"very_high"
],
"impact_options": [
"none",
"low",
"medium",
"high"
],
"_key": null
}
}
Received response:
Request failed with error:
Business Process Models
List Business Process Model Publications
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-process-model-publications',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'append'=> 'statistics,outliers',
'include'=> 'diagram,diagram.model',
'filter[business-model-diagram]'=> '5445fd-2454554-fddffd-5445',
'filter[manual]'=> '1',
'filter[production]'=> '1',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-process-model-publications"
);
const params = {
"append": "statistics,outliers",
"include": "diagram,diagram.model",
"filter[business-model-diagram]": "5445fd-2454554-fddffd-5445",
"filter[manual]": "1",
"filter[production]": "1",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-process-model-publications?append=statistics%2Coutliers&include=diagram%2Cdiagram.model&filter%5Bbusiness-model-diagram%5D=5445fd-2454554-fddffd-5445&filter%5Bmanual%5D=1&filter%5Bproduction%5D=1" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"business_model_diagram_id": "f13363a0-c169-11ee-a104-9f41a69cfc79",
"engine_deployment_reference": "fc0ea076-458b-3a4c-91c5-f826580ba456",
"engine_diagram_reference": "8044fe79-f1b7-3705-99df-f8523a753bed",
"engine_model_reference": "Process_AtqueEtPariatur.",
"_key": null
},
{
"business_model_diagram_id": "f32ffb00-c169-11ee-ac62-67698d5569c1",
"engine_deployment_reference": "6c8e2511-0675-39f1-b705-9a592b9656a9",
"engine_diagram_reference": "ee874a31-c372-385e-878a-b5b74dd17ffe",
"engine_model_reference": "Process_ExercitationemEt.",
"_key": null
}
]
}
Received response:
Request failed with error:
View Business Process Model Publication
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-process-model-publications/corrupti',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'append'=> 'statistics,outliers',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-process-model-publications/corrupti"
);
const params = {
"append": "statistics,outliers",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-process-model-publications/corrupti?append=statistics%2Coutliers" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"business_model_diagram_id": "f517cec0-c169-11ee-9e86-cf9d5a9f5817",
"engine_deployment_reference": "983f4b6b-dc0b-3a5c-b67a-cb76e0674b07",
"engine_diagram_reference": "efd0c455-4e3a-3304-b180-cb93f80b5f29",
"engine_model_reference": "Process_EaQuiDoloribus.",
"_key": null
}
}
Received response:
Request failed with error:
View Business Process Submission Form
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/business-process-model-publications/consequuntur/form',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-process-model-publications/consequuntur/form"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/business-process-model-publications/consequuntur/form" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
[],
[]
]
}
Example response (200):
{
"data": {
"some_string_property": {
"attribute": {
"reference": "some_string_property",
"engine_reference": "someStringProperty",
"type": "string",
"label": "Some String Property",
"value": "122",
},
"some_integer_property": {
"attribute": {
"reference": "some_integer_property",
"engine_reference": "someIntegerProperty",
"type": "integer",
"label": "Some Integer Property",
"value": 122,
},
"some_float_property": {
"attribute": {
"reference": "some_float_property",
"engine_reference": "someFloatProperty",
"type": "float",
"label": "Some Float Property",
"value": 122.0
},
"some_boolean_property": {
"attribute": {
"reference": "some_boolean_property",
"engine_reference": "someBooleanProperty",
"type": "boolean",
"label": "Some Boolean Property",
"value": true
},
"some_date_property": {
"attribute": {
"reference": "some_date_property",
"engine_reference": "someDateProperty",
"type": "date",
"label": "Some Date Property",
"value": "2035-01-01"
},
"some_date_time_property": {
"attribute": {
"reference": "some_date_time_property",
"engine_reference": "someDateTimeProperty",
"type": "date_time",
"label": "Some Date Time Property",
"value": "2035-01-01T00:00:00Z"
},
}
}
Received response:
Request failed with error:
Start Business Process
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/business-process-model-publications/accusamus/start',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'submission' => [
'temporibus',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/business-process-model-publications/accusamus/start"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"submission": [
"temporibus"
]
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/business-process-model-publications/accusamus/start" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"submission\": [
\"temporibus\"
]
}"
Example response (200):
{
"data": {
"business_model_id": "f6f91fc0-c169-11ee-984a-f95e601f27d5",
"version": 640,
"versions": [],
"_key": null
}
}
Received response:
Request failed with error:
Connectors
List Connector Profiles
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/connectors/profiles',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'filter[trashed]'=> 'with,only',
'sort'=> '-created_at',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/profiles"
);
const params = {
"filter[trashed]": "with,only",
"sort": "-created_at",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/connectors/profiles?filter%5Btrashed%5D=with%2Conly&sort=-created_at" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"organization_id": "06f2a780-c16a-11ee-80fa-7bf3a00f6e62",
"label": "modi",
"name": "make",
"version": "v2",
"config": [],
"actions": [
{
"name": "exec_scenario",
"externalName": "exec_scenario"
}
],
"_key": null
},
{
"organization_id": "077cea50-c16a-11ee-98c7-b3d54b37c521",
"label": "omnis",
"name": "make",
"version": "v2",
"config": [],
"actions": [
{
"name": "exec_scenario",
"externalName": "exec_scenario"
}
],
"_key": null
}
]
}
Received response:
Request failed with error:
Create Connector Profile
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/connectors/profiles',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'label' => 'aut',
'name' => 'officia',
'version' => 'suscipit',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/profiles"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"label": "aut",
"name": "officia",
"version": "suscipit"
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/connectors/profiles" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"label\": \"aut\",
\"name\": \"officia\",
\"version\": \"suscipit\"
}"
Example response (200):
{
"data": {
"organization_id": "07f8c8c0-c16a-11ee-b1bc-e390eff833ed",
"label": "expedita",
"name": "make",
"version": "v2",
"config": [],
"actions": [
{
"name": "exec_scenario",
"externalName": "exec_scenario"
}
],
"_key": null
}
}
Received response:
Request failed with error:
View Connector Profile
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/connectors/profiles/numquam',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/profiles/numquam"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/connectors/profiles/numquam" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "08740e40-c16a-11ee-b8b2-9fa5421baebe",
"label": "cupiditate",
"name": "make",
"version": "v2",
"config": [],
"actions": [
{
"name": "exec_scenario",
"externalName": "exec_scenario"
}
],
"_key": null
}
}
Received response:
Request failed with error:
Update Connector Profile
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/connectors/profiles/ut',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'label' => 'qui',
'name' => 'magni',
'version' => 'molestiae',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/profiles/ut"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"label": "qui",
"name": "magni",
"version": "molestiae"
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/connectors/profiles/ut" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"label\": \"qui\",
\"name\": \"magni\",
\"version\": \"molestiae\"
}"
Example response (200):
{
"data": {
"organization_id": "08e995a0-c16a-11ee-b6b2-df8601fc7d59",
"label": "deserunt",
"name": "make",
"version": "v2",
"config": [],
"actions": [
{
"name": "exec_scenario",
"externalName": "exec_scenario"
}
],
"_key": null
}
}
Received response:
Request failed with error:
Delete Connector Profile
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/connectors/profiles/sint',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/profiles/sint"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/connectors/profiles/sint" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "095818e0-c16a-11ee-945b-ef23c33bc23b",
"label": "nemo",
"name": "make",
"version": "v2",
"config": [],
"actions": [
{
"name": "exec_scenario",
"externalName": "exec_scenario"
}
],
"_key": null
}
}
Received response:
Request failed with error:
Restore Connector Profile
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/connectors/profiles/facilis/restore',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/profiles/facilis/restore"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "POST",
headers,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/connectors/profiles/facilis/restore" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "09d26dc0-c16a-11ee-94e7-29af20dff3ec",
"label": "est",
"name": "make",
"version": "v2",
"config": [],
"actions": [
{
"name": "exec_scenario",
"externalName": "exec_scenario"
}
],
"_key": null
}
}
Received response:
Request failed with error:
List Connector Profile Action Config Fields
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/connectors/profiles/et/action/alias/config-fields',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/profiles/et/action/alias/config-fields"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/connectors/profiles/et/action/alias/config-fields" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (403):
Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
{
"message": "Tenant header is missing or is invalid"
}
Received response:
Request failed with error:
List Connector Applications
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/connectors/applications',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'filter[connector_profile_id]'=> 'lorem',
'filter[business_model_id]'=> 'lorem',
'filter[service_task_topic]'=> 'lorem',
'filter[action_reference]'=> 'lorem',
'filter[search]'=> 'lorem',
'sort'=> '-created_at',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/applications"
);
const params = {
"filter[connector_profile_id]": "lorem",
"filter[business_model_id]": "lorem",
"filter[service_task_topic]": "lorem",
"filter[action_reference]": "lorem",
"filter[search]": "lorem",
"sort": "-created_at",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/connectors/applications?filter%5Bconnector_profile_id%5D=lorem&filter%5Bbusiness_model_id%5D=lorem&filter%5Bservice_task_topic%5D=lorem&filter%5Baction_reference%5D=lorem&filter%5Bsearch%5D=lorem&sort=-created_at" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"connector_profile_id": "0acc1770-c16a-11ee-a0f6-a1e088e22f28",
"business_model_id": "0cd50ef0-c16a-11ee-96b8-69730d3fb04b",
"business_model_diagram_id": "0f01c930-c16a-11ee-bb26-051938d6b6ba",
"service_task_topic": "DICTA_VOLUPTATEM_DOLOR",
"action": "in",
"_key": null
},
{
"connector_profile_id": "0f900d50-c16a-11ee-b028-9bf9b00bf3c1",
"business_model_id": "11f4ee80-c16a-11ee-839d-e5c19a06ccbb",
"business_model_diagram_id": "14890370-c16a-11ee-961e-d7f60c7f0dcd",
"service_task_topic": "ET_SIT_DUCIMUS",
"action": "eligendi",
"_key": null
}
]
}
Received response:
Request failed with error:
Create Connector Application
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/connectors/applications',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'connector_profile_id' => 'iste',
'business_model_id' => 'eaque',
'service_task_topic' => 'necessitatibus',
'action_reference' => 'illum',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/applications"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"connector_profile_id": "iste",
"business_model_id": "eaque",
"service_task_topic": "necessitatibus",
"action_reference": "illum"
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/connectors/applications" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"connector_profile_id\": \"iste\",
\"business_model_id\": \"eaque\",
\"service_task_topic\": \"necessitatibus\",
\"action_reference\": \"illum\"
}"
Example response (200):
{
"data": {
"connector_profile_id": "152b4ab0-c16a-11ee-8576-35825fce162b",
"business_model_id": "1745e8f0-c16a-11ee-9306-2d2e60622c03",
"business_model_diagram_id": "197a80d0-c16a-11ee-9e76-476f52c2d4ad",
"service_task_topic": "ELIGENDI_AUT_ARCHITECTO",
"action": "ea",
"_key": null
}
}
Received response:
Request failed with error:
View Connector Application
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/connectors/applications/ex',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/applications/ex"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/connectors/applications/ex" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"connector_profile_id": "1a062940-c16a-11ee-a6c5-ab745d990ce1",
"business_model_id": "1c26b350-c16a-11ee-a30a-431d62bff9d2",
"business_model_diagram_id": "1e4ba940-c16a-11ee-832f-cff2e9fe0aea",
"service_task_topic": "SUSCIPIT_AUT_APERIAM",
"action": "debitis",
"_key": null
}
}
Received response:
Request failed with error:
Update Connector Application
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/connectors/applications/aut',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'service_task_topic' => 'error',
'action_reference' => 'nemo',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/applications/aut"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"service_task_topic": "error",
"action_reference": "nemo"
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/connectors/applications/aut" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"service_task_topic\": \"error\",
\"action_reference\": \"nemo\"
}"
Example response (200):
{
"data": {
"connector_profile_id": "1ed6bf30-c16a-11ee-af0d-a939ead82544",
"business_model_id": "20de2820-c16a-11ee-871d-1b4650486879",
"business_model_diagram_id": "2306dcb0-c16a-11ee-bf1f-55c2467b4b52",
"service_task_topic": "DOLOREMQUE_QUASI_NESCIUNT",
"action": "reiciendis",
"_key": null
}
}
Received response:
Request failed with error:
Delete Connector Application
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/connectors/applications/quis',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/applications/quis"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/connectors/applications/quis" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"connector_profile_id": "23904ef0-c16a-11ee-9c6c-8fd82d8a5e40",
"business_model_id": "25a08410-c16a-11ee-9851-b9f97bcd826a",
"business_model_diagram_id": "27cadbf0-c16a-11ee-8efb-ff3dfc3ef026",
"service_task_topic": "ENIM_ADIPISCI_HIC",
"action": "dolore",
"_key": null
}
}
Received response:
Request failed with error:
List Connector Definitions
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/connectors/definitions',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/connectors/definitions"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/connectors/definitions" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (403):
Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
{
"message": "Tenant header is missing or is invalid"
}
Received response:
Request failed with error:
Users
Assign Organization Units
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/assign-organization-units',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'ids' => [
'atque',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/assign-organization-units"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"ids": [
"atque"
]
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/assign-organization-units" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"ids\": [
\"atque\"
]
}"
Received response:
Request failed with error:
Update
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'in',
'surname' => 'assumenda',
'phone' => 'optio',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "in",
"surname": "assumenda",
"phone": "optio"
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"in\",
\"surname\": \"assumenda\",
\"phone\": \"optio\"
}"
Example response (200):
{
"data": {
"name": "Korey",
"surname": "Jacobs",
"email": "eloy18@example.org",
"phone": "+17656704425",
"email_verified_at": "1987-04-04T19:13:47.000000Z",
"_key": null
}
}
Received response:
Request failed with error:
Delete User
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"name": "Mercedes",
"surname": "Kessler",
"email": "russell.wisoky@example.org",
"phone": "+1-938-309-0025",
"email_verified_at": "1977-01-22T06:46:49.000000Z",
"_key": null
}
}
Received response:
Request failed with error:
Restore User
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/restore',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/restore"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "POST",
headers,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/users/0212d300-8534-11ed-828a-9d6be7cc0d7a/restore" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"name": "Myah",
"surname": "Denesik",
"email": "nbeier@example.org",
"phone": "(904) 698-4669",
"email_verified_at": "2021-03-17T01:46:35.000000Z",
"_key": null
}
}
Received response:
Request failed with error:
Forms
List Forms
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/forms',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/forms"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/forms" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"organization_id": "524a7f90-c16a-11ee-96d8-8fe5e97a59f2",
"name": "velit",
"layout": [],
"fields": [],
"_key": null
},
{
"organization_id": "52c4a820-c16a-11ee-b5c1-bfac784f1e8c",
"name": "itaque",
"layout": [],
"fields": [],
"_key": null
}
]
}
Received response:
Request failed with error:
Create Form
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/forms',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'consequatur',
'layout' => [],
'fields' => [],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/forms"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "consequatur",
"layout": [],
"fields": []
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/forms" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"consequatur\",
\"layout\": [],
\"fields\": []
}"
Example response (200):
{
"data": {
"organization_id": "534443d0-c16a-11ee-900b-775f14e56538",
"name": "nesciunt",
"layout": [],
"fields": [],
"_key": null
}
}
Received response:
Request failed with error:
View Form
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "53c28270-c16a-11ee-a3fd-eb2b1afe8ac2",
"name": "qui",
"layout": [],
"fields": [],
"_key": null
}
}
Received response:
Request failed with error:
Update Form
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->put(
'https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'name' => 'magnam',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"name": "magnam"
};
fetch(url, {
method: "PUT",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request PUT \
"https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"name\": \"magnam\"
}"
Example response (200):
{
"data": {
"organization_id": "543f8560-c16a-11ee-9c6f-adb6e3fe5a2b",
"name": "atque",
"layout": [],
"fields": [],
"_key": null
}
}
Received response:
Request failed with error:
Delete Form
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/forms/1a36dcf0-2c60-11ee-9f3c-a70088ee661c" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"organization_id": "54bcfc00-c16a-11ee-b8ca-47cec0f0338a",
"name": "nihil",
"layout": [],
"fields": [],
"_key": null
}
}
Received response:
Request failed with error:
Tasks
List Tasks
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/tasks',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'reservations,eligible_users,eligible_organization_units',
'filter[name]'=> 'baba',
'filter[eligible]'=> '1',
'filter[active]'=> '1',
'filter[due]'=> '1',
'filter[due-today]'=> '1',
'filter[process_instance]'=> '54fffd-445fd-fds55',
'filter[engine_definition]'=> 'Activity_1n0qsrj',
'filter[eligible_by_organization_units]'=> 'test1,test2',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/tasks"
);
const params = {
"include": "reservations,eligible_users,eligible_organization_units",
"filter[name]": "baba",
"filter[eligible]": "1",
"filter[active]": "1",
"filter[due]": "1",
"filter[due-today]": "1",
"filter[process_instance]": "54fffd-445fd-fds55",
"filter[engine_definition]": "Activity_1n0qsrj",
"filter[eligible_by_organization_units]": "test1,test2",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/tasks?include=reservations%2Celigible_users%2Celigible_organization_units&filter%5Bname%5D=baba&filter%5Beligible%5D=1&filter%5Bactive%5D=1&filter%5Bdue%5D=1&filter%5Bdue-today%5D=1&filter%5Bprocess_instance%5D=54fffd-445fd-fds55&filter%5Bengine_definition%5D=Activity_1n0qsrj&filter%5Beligible_by_organization_units%5D=test1%2Ctest2" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": [
{
"bounty": 10,
"environment_id": "55b2cb40-c16a-11ee-85c8-6188b740fb6a",
"engine_reference": "d0d13f41-23f6-3e77-8d44-628f4ca53113",
"name": "Eos optio qui laudantium amet enim. Recusandae eaque quos quo est eligendi in unde eum. Porro harum qui dicta distinctio qui ipsa molestias dicta.",
"description": "Caterpillar; and it was over at last, more calmly, though still sobbing a little before she had plenty of time as she spoke. (The unfortunate little Bill had left off writing on his spectacles and.",
"fields": [],
"fields_values": null,
"follow_up_at": "2009-07-02T12:52:34.000000Z",
"due_at": "2011-05-05T20:54:57.000000Z",
"current_user_active_reservation": null,
"_key": null
},
{
"bounty": 10,
"environment_id": "5645de80-c16a-11ee-be3c-45ef5e541318",
"engine_reference": "31a79990-dadf-3f3f-8e34-c906cd6b1cba",
"name": "Tempore quis saepe non dolor. Sapiente assumenda id velit similique. Eius molestiae maiores animi rerum earum qui. Qui omnis cum dolorem.",
"description": "Duchess: 'what a clear way you go,' said the King; and the great question is, what did the Dormouse began in a low trembling voice, '--and I hadn't to bring tears into her eyes--and still as she.",
"fields": [],
"fields_values": null,
"follow_up_at": "1982-03-22T14:11:26.000000Z",
"due_at": "1995-03-21T17:35:28.000000Z",
"current_user_active_reservation": null,
"_key": null
}
]
}
Received response:
Request failed with error:
View Task
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/tasks/rerum',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'query' => [
'include'=> 'reservations,eligible_users,eligible_organization_units',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/tasks/rerum"
);
const params = {
"include": "reservations,eligible_users,eligible_organization_units",
};
Object.keys(params)
.forEach(key => url.searchParams.append(key, params[key]));
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/tasks/rerum?include=reservations%2Celigible_users%2Celigible_organization_units" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"bounty": 10,
"environment_id": "56c5e330-c16a-11ee-9d46-71677ae06f6f",
"engine_reference": "cef7ef41-2be4-3508-a540-0d747280127d",
"name": "Consequatur quae et minus corrupti asperiores. Vel dolor hic itaque ut nesciunt alias.",
"description": "I think I could, if I shall never get to the beginning again?' Alice ventured to say. 'What is his sorrow?' she asked the Gryphon, and the other two were using it as to bring tears into her eyes.",
"fields": [],
"fields_values": null,
"follow_up_at": "1987-07-25T03:27:25.000000Z",
"due_at": "1995-05-18T22:26:49.000000Z",
"current_user_active_reservation": null,
"_key": null
}
}
Received response:
Request failed with error:
Reserve Task
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/tasks/autem/reservation',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/tasks/autem/reservation"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "POST",
headers,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/tasks/autem/reservation" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"bounty": 10,
"environment_id": "57403c80-c16a-11ee-b660-637ee87982d1",
"engine_reference": "d2377ac2-7d15-3314-ae72-cf2fef2adebe",
"name": "Quia quidem in dolores labore eveniet. Est nam nisi officiis et. Velit officiis voluptates ipsa soluta non cumque quo aut. Autem similique nulla odio incidunt hic delectus.",
"description": "KNOW IT TO BE TRUE--\" that's the jury, of course--\"I GAVE HER ONE, THEY GAVE HIM TWO--\" why, that must be what he did with the strange creatures of her head struck against the roof of the hall: in.",
"fields": [],
"fields_values": null,
"follow_up_at": "2010-07-27T11:10:26.000000Z",
"due_at": "2001-10-20T04:11:10.000000Z",
"current_user_active_reservation": null,
"_key": null
}
}
Received response:
Request failed with error:
Unreserve Task
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->delete(
'https://base.stackflows.com/api/v2/tasks/voluptas/reservation',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/tasks/voluptas/reservation"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "DELETE",
headers,
}).then(response => response.json());
curl --request DELETE \
"https://base.stackflows.com/api/v2/tasks/voluptas/reservation" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"bounty": 10,
"environment_id": "57bf4770-c16a-11ee-b6ed-7da24f033e14",
"engine_reference": "1e3f45a5-4080-3ff6-b627-298f854fce13",
"name": "Dolore fugit natus minima eum. Ea aut expedita ut est velit architecto aut. Consequuntur quia libero occaecati non dolores.",
"description": "She had quite forgotten the Duchess sang the second time round, she found she had caught the baby violently up and walking off to the Mock Turtle. 'She can't explain it,' said the cook. The King.",
"fields": [],
"fields_values": null,
"follow_up_at": "1977-10-26T20:38:33.000000Z",
"due_at": "1983-08-16T00:06:03.000000Z",
"current_user_active_reservation": null,
"_key": null
}
}
Received response:
Request failed with error:
Complete Task
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/tasks/consectetur/complete',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/tasks/consectetur/complete"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "POST",
headers,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/tasks/consectetur/complete" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
Example response (200):
{
"data": {
"bounty": 10,
"environment_id": "583d3ae0-c16a-11ee-9d30-7116a303fad7",
"engine_reference": "a9e10d62-3465-3cae-9ad5-c6ce35bf437e",
"name": "Ducimus nam non rem quia iure illo minus. Unde perferendis aut aliquam est facilis nihil excepturi. Odit ut placeat ipsa assumenda incidunt.",
"description": "The master was an old Turtle--we used to say it over) '--yes, that's about the games now.' CHAPTER X. The Lobster Quadrille is!' 'No, indeed,' said Alice. 'Why?' 'IT DOES THE BOOTS AND SHOES.' the.",
"fields": [],
"fields_values": null,
"follow_up_at": "1996-11-04T08:33:43.000000Z",
"due_at": "1982-07-28T13:31:02.000000Z",
"current_user_active_reservation": null,
"_key": null
}
}
Received response:
Request failed with error:
Analyses
List Analyses
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/analyses',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'references' => [
'neque',
],
'time_range_start' => '2024-02-02T01:28:18',
'time_range_end' => '2024-02-02T01:28:18',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/analyses"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"references": [
"neque"
],
"time_range_start": "2024-02-02T01:28:18",
"time_range_end": "2024-02-02T01:28:18"
};
fetch(url, {
method: "GET",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/analyses" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"references\": [
\"neque\"
],
\"time_range_start\": \"2024-02-02T01:28:18\",
\"time_range_end\": \"2024-02-02T01:28:18\"
}"
Example response (403):
Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
{
"message": "Tenant header is missing or is invalid"
}
Received response:
Request failed with error:
List Analyses
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/summaries',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'references' => [
'sint',
],
'time_range_start' => '2024-02-02T01:28:18',
'time_range_end' => '2024-02-02T01:28:18',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/summaries"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"references": [
"sint"
],
"time_range_start": "2024-02-02T01:28:18",
"time_range_end": "2024-02-02T01:28:18"
};
fetch(url, {
method: "GET",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/summaries" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"references\": [
\"sint\"
],
\"time_range_start\": \"2024-02-02T01:28:18\",
\"time_range_end\": \"2024-02-02T01:28:18\"
}"
Example response (403):
Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
{
"message": "Tenant header is missing or is invalid"
}
Received response:
Request failed with error:
Environment
Business Process Instances
List Business Process Instances
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/environment/blanditiis/business-process-instances',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'activities' => [
'ad',
],
'active_only' => true,
'sort_by' => 'repellat',
'sort_order' => 'desc',
'page' => [
'number' => 18,
'size' => 10,
],
'publication_engine_diagram_reference' => 'quasi',
'publication_engine_model_reference' => 'aperiam',
'publication_engine_deployment_reference' => 'quod',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environment/blanditiis/business-process-instances"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"activities": [
"ad"
],
"active_only": true,
"sort_by": "repellat",
"sort_order": "desc",
"page": {
"number": 18,
"size": 10
},
"publication_engine_diagram_reference": "quasi",
"publication_engine_model_reference": "aperiam",
"publication_engine_deployment_reference": "quod"
};
fetch(url, {
method: "GET",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/environment/blanditiis/business-process-instances" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"activities\": [
\"ad\"
],
\"active_only\": true,
\"sort_by\": \"repellat\",
\"sort_order\": \"desc\",
\"page\": {
\"number\": 18,
\"size\": 10
},
\"publication_engine_diagram_reference\": \"quasi\",
\"publication_engine_model_reference\": \"aperiam\",
\"publication_engine_deployment_reference\": \"quod\"
}"
Example response (200):
{
"data": [
{
"reference": "dolore",
"startedAt": {
"date": "1983-08-25 10:48:27.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1977-01-22 04:24:06.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"publication": {
"business_model_diagram_id": "29fc0530-c16a-11ee-90e2-91782c57d6b1",
"engine_deployment_reference": "df571db3-345a-3a68-a930-928a6c49fb4c",
"engine_diagram_reference": "6ba38f9d-8a24-38e9-a211-517721965701",
"engine_model_reference": "Process_QuiaEstEt."
},
"context": "id",
"attributes": []
},
{
"reference": "dolorem",
"startedAt": {
"date": "2022-12-29 08:12:33.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1982-07-13 23:17:53.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"publication": {
"business_model_diagram_id": "2c5de320-c16a-11ee-ba40-ff11e98e5c68",
"engine_deployment_reference": "25ee6683-62cb-3e34-915e-4d74ab40ed88",
"engine_diagram_reference": "fa250f11-cc89-3cc1-ada4-cb2af4170b11",
"engine_model_reference": "Process_QuidemUllam."
},
"context": "quis",
"attributes": []
}
]
}
Received response:
Request failed with error:
View Business Process Instance
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/environment/et/business-process-instances/quo',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environment/et/business-process-instances/quo"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/environment/et/business-process-instances/quo" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"reference": "quia",
"startedAt": {
"date": "2003-02-04 03:32:16.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1985-07-15 07:51:36.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"publication": {
"business_model_diagram_id": "2e855640-c16a-11ee-a9a7-17e1472d2087",
"engine_deployment_reference": "cd197594-d1c6-3d2b-b12d-6c3a28c5071a",
"engine_diagram_reference": "b02f9117-f1a6-3291-8601-464068f94a7d",
"engine_model_reference": "Process_MagniMinima."
},
"context": "harum",
"attributes": []
}
}
Received response:
Request failed with error:
Business Activity Instances
List Business Activity Instances
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/environment/dignissimos/business-activity-instances',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'activity_reference' => 'architecto',
'processed' => false,
'sort_by' => 'est',
'sort_order' => 'desc',
'page' => [
'number' => 2,
'size' => 12,
],
'diagram_engine_reference' => 'sed',
'process_instance_reference' => 'eaque',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environment/dignissimos/business-activity-instances"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"activity_reference": "architecto",
"processed": false,
"sort_by": "est",
"sort_order": "desc",
"page": {
"number": 2,
"size": 12
},
"diagram_engine_reference": "sed",
"process_instance_reference": "eaque"
};
fetch(url, {
method: "GET",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/environment/dignissimos/business-activity-instances" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"activity_reference\": \"architecto\",
\"processed\": false,
\"sort_by\": \"est\",
\"sort_order\": \"desc\",
\"page\": {
\"number\": 2,
\"size\": 12
},
\"diagram_engine_reference\": \"sed\",
\"process_instance_reference\": \"eaque\"
}"
Example response (200):
{
"data": [
{
"reference": "omnis",
"name": "sit",
"type": "tempora",
"startedAt": {
"date": "2014-09-03 20:36:20.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1984-01-14 03:32:47.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"processInstance": {
"reference": "recusandae",
"startedAt": {
"date": "1977-10-01 04:39:37.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1988-02-01 13:29:56.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"publication": {
"business_model_diagram_id": "30a58c60-c16a-11ee-a96e-f55da3976208",
"engine_deployment_reference": "9f8b38da-90be-3da2-b09e-a938b083d77b",
"engine_diagram_reference": "ac8d9f0e-a138-34fb-a8ce-66aeb92c28bb",
"engine_model_reference": "Process_Voluptatibus."
},
"context": "voluptas",
"attributes": []
}
},
{
"reference": "nihil",
"name": "doloribus",
"type": "non",
"startedAt": {
"date": "1985-10-14 07:55:12.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1977-01-14 22:33:53.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"processInstance": {
"reference": "temporibus",
"startedAt": {
"date": "1975-09-20 04:37:38.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1991-02-19 05:54:21.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"publication": {
"business_model_diagram_id": "32b760a0-c16a-11ee-8828-f98cfb91142f",
"engine_deployment_reference": "c2ca05cf-0ae4-32f1-be2b-82bde5227aba",
"engine_diagram_reference": "b2e221b0-fbd8-3fc5-b1df-0a35ef6a1886",
"engine_model_reference": "Process_UtExplicabo."
},
"context": "repudiandae",
"attributes": []
}
}
]
}
Received response:
Request failed with error:
View Business Activity Instance
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/environment/aut/business-activity-instances/pariatur',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environment/aut/business-activity-instances/pariatur"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "GET",
headers,
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/environment/aut/business-activity-instances/pariatur" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"reference": "consequatur",
"name": "est",
"type": "nesciunt",
"startedAt": {
"date": "1992-01-01 14:33:02.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1997-04-21 04:45:38.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"processInstance": {
"reference": "est",
"startedAt": {
"date": "2018-05-10 08:38:56.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "2009-08-02 11:44:39.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"publication": {
"business_model_diagram_id": "34d21950-c16a-11ee-8377-999830aa47f9",
"engine_deployment_reference": "d9678a42-f15e-3ba2-8ec5-b4ba26cdc9b2",
"engine_diagram_reference": "c85d2fa4-8743-35a5-93e3-5f5f91209e82",
"engine_model_reference": "Process_AutemIpsam."
},
"context": "hic",
"attributes": []
}
}
}
Received response:
Request failed with error:
Events
POST api/v2/environment/{environment_id}/events/{reference}/send-message
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/environment/est/events/ipsam/send-message',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environment/est/events/ipsam/send-message"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "POST",
headers,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/environment/est/events/ipsam/send-message" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Received response:
Request failed with error:
POST api/v2/environment/{environment_id}/events/{reference}/send-signal
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/environment/eveniet/events/molestiae/send-signal',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environment/eveniet/events/molestiae/send-signal"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "POST",
headers,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/environment/eveniet/events/molestiae/send-signal" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Received response:
Request failed with error:
Service Tasks
List Service Tasks
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->get(
'https://base.stackflows.com/api/v2/environment/consequatur/service-tasks',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'topic' => 'consequatur',
'activities' => [
'aspernatur',
],
'active_only' => true,
'sort_by' => 'et',
'sort_order' => 'asc',
'page' => [
'number' => 1,
'size' => 13,
],
'process_instance_references' => [
'fuga',
],
'publication_engine_diagram_reference' => 'delectus',
'publication_engine_model_reference' => 'omnis',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environment/consequatur/service-tasks"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"topic": "consequatur",
"activities": [
"aspernatur"
],
"active_only": true,
"sort_by": "et",
"sort_order": "asc",
"page": {
"number": 1,
"size": 13
},
"process_instance_references": [
"fuga"
],
"publication_engine_diagram_reference": "delectus",
"publication_engine_model_reference": "omnis"
};
fetch(url, {
method: "GET",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request GET \
--get "https://base.stackflows.com/api/v2/environment/consequatur/service-tasks" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"topic\": \"consequatur\",
\"activities\": [
\"aspernatur\"
],
\"active_only\": true,
\"sort_by\": \"et\",
\"sort_order\": \"asc\",
\"page\": {
\"number\": 1,
\"size\": 13
},
\"process_instance_references\": [
\"fuga\"
],
\"publication_engine_diagram_reference\": \"delectus\",
\"publication_engine_model_reference\": \"omnis\"
}"
Example response (200):
{
"data": [
{
"reference": "id",
"topic": "excepturi",
"suspended": false,
"priority": 798803917,
"environment": {
"engine_id": "3556b160-c16a-11ee-8cf9-2963f09ea677",
"engine_reference": "3c09208e-1715-3f13-912d-e239d814c530",
"production": false,
"name": "unde",
"auth_token": "f9596ca7-d3ba-3905-b5ac-9ce1225ef7b3"
},
"activity": {
"name": "exercitationem",
"reference": "quasi"
},
"instance": {
"reference": "voluptatem",
"startedAt": {
"date": "2019-02-04 20:12:47.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1970-12-30 19:13:04.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"publication": {
"business_model_diagram_id": "377987f0-c16a-11ee-b554-e5007547dd07",
"engine_deployment_reference": "3ef496e4-6d0a-3769-8942-0890d001dbb8",
"engine_diagram_reference": "af2c34b5-0e0c-3158-9b91-0248d87e0b44",
"engine_model_reference": "Process_IustoAccusantium."
},
"context": "quaerat",
"attributes": []
},
"attributes": []
},
{
"reference": "natus",
"topic": "optio",
"suspended": false,
"priority": 39931,
"environment": {
"engine_id": "38042fd0-c16a-11ee-bad3-2badfb06e9b5",
"engine_reference": "2da6f49c-4a3c-3659-8897-8cd5b49e015f",
"production": false,
"name": "voluptas",
"auth_token": "a53bea65-eaea-3056-8ba9-7d37cc6de826"
},
"activity": {
"name": "atque",
"reference": "veniam"
},
"instance": {
"reference": "officiis",
"startedAt": {
"date": "2014-05-16 15:47:27.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1979-03-04 11:32:36.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"publication": {
"business_model_diagram_id": "3a49a1f0-c16a-11ee-9f3d-273e0a8c0aab",
"engine_deployment_reference": "285b6d43-891e-3570-8980-8492a477fd70",
"engine_diagram_reference": "f4ac9010-4b90-317e-8899-1f2336d9e805",
"engine_model_reference": "Process_EosBeataeEt."
},
"context": "voluptas",
"attributes": []
},
"attributes": []
}
]
}
Received response:
Request failed with error:
Lock a Service Task
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/environment/quibusdam/service-tasks/voluptate/lock',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environment/quibusdam/service-tasks/voluptate/lock"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "POST",
headers,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/environment/quibusdam/service-tasks/voluptate/lock" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"reference": "vel",
"topic": "maiores",
"suspended": true,
"priority": 780403949,
"environment": {
"engine_id": "3ad664d0-c16a-11ee-922e-8fcf7dd4f5e1",
"engine_reference": "e6ceeb91-3ef3-3b32-975b-f4dae1925848",
"production": false,
"name": "sed",
"auth_token": "a9fcd589-b742-3fee-8642-50ef7f98de24"
},
"activity": {
"name": "illo",
"reference": "ipsa"
},
"instance": {
"reference": "voluptatibus",
"startedAt": {
"date": "1972-08-11 08:50:05.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1990-03-06 19:12:23.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"publication": {
"business_model_diagram_id": "3ce4fec0-c16a-11ee-a917-8b1f5de2a494",
"engine_deployment_reference": "1b1e7d01-e556-3103-9b05-187f0b104f79",
"engine_diagram_reference": "281efa80-0a3a-30cf-abdf-943dc4df0de8",
"engine_model_reference": "Process_VoluptasQuisAut."
},
"context": "quis",
"attributes": []
},
"attributes": []
}
}
Received response:
Request failed with error:
Unlock a Service Task
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/environment/officiis/service-tasks/possimus/unlock',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environment/officiis/service-tasks/possimus/unlock"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
fetch(url, {
method: "POST",
headers,
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/environment/officiis/service-tasks/possimus/unlock" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx"
Example response (200):
{
"data": {
"reference": "tenetur",
"topic": "similique",
"suspended": false,
"priority": 8951637,
"environment": {
"engine_id": "3d669010-c16a-11ee-b779-3b1391a7d995",
"engine_reference": "5acc470c-3704-3232-b5d9-58ef5255ee9f",
"production": false,
"name": "qui",
"auth_token": "bd96175d-17f4-33a0-a146-3d54d052a95b"
},
"activity": {
"name": "harum",
"reference": "delectus"
},
"instance": {
"reference": "maiores",
"startedAt": {
"date": "1975-10-25 20:43:52.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "1970-07-24 08:30:43.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"publication": {
"business_model_diagram_id": "3f745aa0-c16a-11ee-a490-f3baaec8ffe7",
"engine_deployment_reference": "e6170143-8d1c-364e-84e6-455ae2ad9c63",
"engine_diagram_reference": "4136fad8-8351-3101-b8b8-0e6252b9c7d5",
"engine_model_reference": "Process_VelNisiQuasiAut."
},
"context": "dolore",
"attributes": []
},
"attributes": []
}
}
Received response:
Request failed with error:
Serve a Service Task
requires authentication
Example request:
$client = new \GuzzleHttp\Client();
$response = $client->post(
'https://base.stackflows.com/api/v2/environment/possimus/service-tasks/nulla/serve',
[
'headers' => [
'Authorization' => 'Bearer {OPENID_CONNECT_TOKEN}',
'Content-Type' => 'application/json',
'Accept' => 'application/json',
'X-Tenant' => 'xxxxx-xxxx-xxxxxxxxxxxxxxxxxx',
],
'json' => [
'submission' => [
'assumenda',
],
],
]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
const url = new URL(
"https://base.stackflows.com/api/v2/environment/possimus/service-tasks/nulla/serve"
);
const headers = {
"Authorization": "Bearer {OPENID_CONNECT_TOKEN}",
"Content-Type": "application/json",
"Accept": "application/json",
"X-Tenant": "xxxxx-xxxx-xxxxxxxxxxxxxxxxxx",
};
let body = {
"submission": [
"assumenda"
]
};
fetch(url, {
method: "POST",
headers,
body: JSON.stringify(body),
}).then(response => response.json());
curl --request POST \
"https://base.stackflows.com/api/v2/environment/possimus/service-tasks/nulla/serve" \
--header "Authorization: Bearer {OPENID_CONNECT_TOKEN}" \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "X-Tenant: xxxxx-xxxx-xxxxxxxxxxxxxxxxxx" \
--data "{
\"submission\": [
\"assumenda\"
]
}"
Example response (200):
{
"data": {
"reference": "et",
"topic": "nobis",
"suspended": false,
"priority": 70,
"environment": {
"engine_id": "400bb170-c16a-11ee-935e-97405198a454",
"engine_reference": "dc21c2d1-1b4e-3c0e-bc32-1ae953a51ee0",
"production": true,
"name": "ea",
"auth_token": "326eef64-ce13-3a9c-a732-a331ef2a215e"
},
"activity": {
"name": "aut",
"reference": "ut"
},
"instance": {
"reference": "facilis",
"startedAt": {
"date": "1984-03-06 04:17:36.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"endedAt": {
"date": "2014-11-11 07:00:13.000000",
"timezone_type": 3,
"timezone": "UTC"
},
"publication": {
"business_model_diagram_id": "4204d640-c16a-11ee-a8b3-75fdbb7aab52",
"engine_deployment_reference": "2db75df6-f033-37f8-968e-d61cce8b4f4d",
"engine_diagram_reference": "c52231f5-cbcb-3ae2-b381-74a4a6aee2fc",
"engine_model_reference": "Process_AutMollitia."
},
"context": "non",
"attributes": []
},
"attributes": []
}
}
Received response:
Request failed with error: