Fluida API v1.0.0
Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.
Fluida API integration guide
Base URLs:
Authentication
oAuth2 authentication.
- Flow: implicit
- Authorization URL = https://app.fluida.io/oauth/authorize
Scope | Scope Description |
---|---|
write:schedule | Schedule write |
read:expense_type | Expense type read |
write:activity_types | Activity types write |
write:expense_type | Expense type write |
write:justification | Justification write |
read:company_communication | Company communication read |
write:request | Request write |
write:workplace_override | Workplace override write |
read:contract | Contract read |
read:customer | Customer read |
write:contract_day_schedule_change | Contract day schedule change write |
write:company | Company write |
write:activity_type | Activity type write |
read:team | Team read |
read:activity_type | Activity type read |
write:customers | Customers write |
write:justification_type | Justification type write |
read:expense | Expense read |
write:orders | Orders write |
read:request | Request read |
read:stamping | Stamping read |
read:calendar | Calendar read |
read:expense_report | Expense report read |
read:justification | Justification read |
write:activity | Activity write |
write:company_communication | Company communication write |
write:user_document | User document write |
read:workplace_override | Workplace override read |
write:expense_report | Expense report write |
write:team | Team write |
read:orders | Orders read |
write:expense | Expense write |
read:activity_types | Activity types read |
write:stamping | Stamping write |
read:export | Export read |
read:order | Order read |
write:activities | Activities write |
read:holiday | Holiday read |
write:stamping_device | Stamping device write |
write:stamping_area | Stamping area write |
read:schedule | Schedule read |
write:customer | Customer write |
write:contract | Contract write |
read:stamping_area | Stamping area read |
read:company | Company read |
read:contract_day_schedule_change | Contract day schedule change read |
write:holiday | Holiday write |
read:customers | Customers read |
read:user_document | User document read |
read:activity | Activity read |
read:company_communication_message | Company communication message read |
read:justification_type | Justification type read |
write:company_communication_message | Company communication message write |
read:stamping_device | Stamping device read |
write:export | Export write |
read:activities | Activities read |
write:order | Order write |
- API Key (ApiKey)
- Parameter Name: x-fluida-app-uuid, in: header. Api Key for authorized app
Company
Creates a team for a given company
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/teams \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies/{company_id}/teams HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"team_leader_ids": [
"46568afb-1eab-447b-9289-c7ca989fbbe7",
"8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
],
"subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
"name": "Thompson-Emard",
"company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
"code": "47395 Gus Unions"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/teams',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/teams', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/teams', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/teams", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies/{company_id}/teams
Creates a team for a given company...
Body parameter
{
"team_leader_ids": [
"46568afb-1eab-447b-9289-c7ca989fbbe7",
"8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
],
"subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
"name": "Thompson-Emard",
"company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
"code": "47395 Gus Unions"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
body | body | Team | false | team attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Renders a list of teams for a given company id
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/teams \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/teams HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/teams',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/teams', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/teams', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/teams", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/teams
Renders a list of teams for a given company id...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
Example responses
200 Response
[
{
"team_leader_ids": [
"46568afb-1eab-447b-9289-c7ca989fbbe7",
"8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
],
"subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
"name": "Thompson-Emard",
"company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
"code": "47395 Gus Unions"
}
]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Teams |
Get company extension status
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id/status \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id/status HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id/status',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id/status',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id/status', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id/status', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id/status");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id/status", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/:company_id/extension/:extension_id/status
Get company extension status...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company_id |
extension_id | path | string | true | extension_id |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | CompanyExtensionStatus |
401 | Unauthorized | Unauthorized | Unauthorized |
Upgrades a contract to team leader
Code samples
# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
PUT https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"team_id": "string",
"contract_id": "string"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract',
{
method: 'PUT',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.put 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.put('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('PUT','https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
PUT /api/v1/companies/{company_id}/teams/{team_id}/upgrade_contract
Upgrades a contract to team leader...
Body parameter
{
"team_id": "string",
"contract_id": "string"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
team_id | path | string | true | team id |
body | body | ContractTeamParams | false | team attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Creates a company communication message
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/:company_id/communications \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies/:company_id/communications HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"subject": "string",
"status": "string",
"sender_id": "string",
"send_at": "string",
"recurrent_until": "string",
"recurrent": "string",
"message": "string",
"destination_team_ids": [
"string"
],
"destination_subsidiary_ids": [
"string"
],
"company_id": "string",
"change_log": [
{}
],
"attachments": [
{
"name": "string",
"mime": "string",
"id": "string"
}
],
"action_required": "string"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/communications',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies/:company_id/communications',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies/:company_id/communications', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies/:company_id/communications', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/:company_id/communications", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies/:company_id/communications
Creates a company communication message...
Body parameter
{
"subject": "string",
"status": "string",
"sender_id": "string",
"send_at": "string",
"recurrent_until": "string",
"recurrent": "string",
"message": "string",
"destination_team_ids": [
"string"
],
"destination_subsidiary_ids": [
"string"
],
"company_id": "string",
"change_log": [
{}
],
"attachments": [
{
"name": "string",
"mime": "string",
"id": "string"
}
],
"action_required": "string"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
body | body | Communication | false | company communication |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Shows company communications
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/:company_id/communications HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/communications',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/:company_id/communications
Shows company communications...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
year | query | integer | false | filter communications by year |
status | query | string | false | filter communications by status |
recurring | query | boolean | false | filter communications by recurring state |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Communications |
401 | Unauthorized | Unauthorized | Unauthorized |
Updates a company extension
Code samples
# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/:company_id/extension \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
PUT https://api.fluida.io/api/v1/companies/:company_id/extension HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"extension_id": "string",
"extension_code": "string",
"enabled": true,
"configuration": {},
"company_id": "string"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/extension',
{
method: 'PUT',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.put 'https://api.fluida.io/api/v1/companies/:company_id/extension',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.put('https://api.fluida.io/api/v1/companies/:company_id/extension', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('PUT','https://api.fluida.io/api/v1/companies/:company_id/extension', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/extension");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/:company_id/extension", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
PUT /api/v1/companies/:company_id/extension
Updates a company extension...
Body parameter
{
"extension_id": "string",
"extension_code": "string",
"enabled": true,
"configuration": {},
"company_id": "string"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
body | body | CompanyExtension | false | extension attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Downgrades a contract from team leader
Code samples
# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
PUT https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"team_id": "string",
"contract_id": "string"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract',
{
method: 'PUT',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.put 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.put('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('PUT','https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
PUT /api/v1/companies/{company_id}/teams/{team_id}/downgrade_contract
Downgrades a contract from team leader...
Body parameter
{
"team_id": "string",
"contract_id": "string"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
team_id | path | string | true | team id |
body | body | ContractTeamParams | false | team attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Updates a teams for a given company
Code samples
# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id} \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
PUT https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"team_leader_ids": [
"46568afb-1eab-447b-9289-c7ca989fbbe7",
"8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
],
"subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
"name": "Thompson-Emard",
"company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
"code": "47395 Gus Unions"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id}',
{
method: 'PUT',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.put 'https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.put('https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('PUT','https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/:company_id/teams/{team_id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
PUT /api/v1/companies/:company_id/teams/{team_id}
Updates a teams for a given company...
Body parameter
{
"team_leader_ids": [
"46568afb-1eab-447b-9289-c7ca989fbbe7",
"8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
],
"subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
"name": "Thompson-Emard",
"company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
"code": "47395 Gus Unions"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
team_id | path | string | true | team id |
body | body | Team | false | team attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Renders a list of authorized scopes for a given company id
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/authorized/scopes", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/authorized/scopes
Renders a list of authorized scopes for a given company id...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
Example responses
200 Response
[
{
"name": "Justification",
"mode": [
"read",
"write"
],
"api": "justification"
}
]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Scopes |
Renders a list of company holidays
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/holidays \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/holidays HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/holidays',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/holidays',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/holidays', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/holidays', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/holidays");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/holidays", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/holidays
Renders a list of company holidays...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
Example responses
200 Response
[
{
"recurrent_until": "string",
"recurrent": "string",
"name": "string",
"is_worker_holiday": true,
"day": "string"
}
]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Holidays |
Updates a company communication
Code samples
# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/:company_id/communications/:id \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
PUT https://api.fluida.io/api/v1/companies/:company_id/communications/:id HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"subject": "string",
"status": "string",
"sender_id": "string",
"send_at": "string",
"recurrent_until": "string",
"recurrent": "string",
"message": "string",
"destination_team_ids": [
"string"
],
"destination_subsidiary_ids": [
"string"
],
"company_id": "string",
"change_log": [
{}
],
"attachments": [
{
"name": "string",
"mime": "string",
"id": "string"
}
],
"action_required": "string"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/:id',
{
method: 'PUT',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.put 'https://api.fluida.io/api/v1/companies/:company_id/communications/:id',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.put('https://api.fluida.io/api/v1/companies/:company_id/communications/:id', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('PUT','https://api.fluida.io/api/v1/companies/:company_id/communications/:id', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/:id");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/:company_id/communications/:id", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
PUT /api/v1/companies/:company_id/communications/:id
Updates a company communication...
Body parameter
{
"subject": "string",
"status": "string",
"sender_id": "string",
"send_at": "string",
"recurrent_until": "string",
"recurrent": "string",
"message": "string",
"destination_team_ids": [
"string"
],
"destination_subsidiary_ids": [
"string"
],
"company_id": "string",
"change_log": [
{}
],
"attachments": [
{
"name": "string",
"mime": "string",
"id": "string"
}
],
"action_required": "string"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
id | path | string | true | communication id |
company_id | path | string | true | company id |
body | body | Communication | false | communication |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Shows a communication
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications/:id \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/:company_id/communications/:id HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/:id',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications/:id',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications/:id', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications/:id', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/:id");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications/:id", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/:company_id/communications/:id
Shows a communication...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
id | path | string | true | communication id |
company_id | path | string | true | company id |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Communication |
401 | Unauthorized | Unauthorized | Unauthorized |
Shows communication reports
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/report", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/:company_id/communications/:communication_id/report
Shows communication reports...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
communication_id | path | string | true | communication id |
company_id | path | string | true | company id |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | CommunicationReports |
401 | Unauthorized | Unauthorized | Unauthorized |
List fluida extensions
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/fluida_extensions \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/fluida_extensions HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/fluida_extensions',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/fluida_extensions',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/fluida_extensions', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/fluida_extensions', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/fluida_extensions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/fluida_extensions", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/fluida_extensions
List fluida extensions...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
category | query | string | false | filter by category |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | FluidaExtensions |
401 | Unauthorized | Unauthorized | Unauthorized |
Renders a list of all holidays
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/all_holidays \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/all_holidays HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/all_holidays',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/all_holidays',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/all_holidays', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/all_holidays', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/all_holidays");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/all_holidays", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/all_holidays
Renders a list of all holidays...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
Example responses
200 Response
[
{
"recurrent_until": "string",
"recurrent": "string",
"name": "string",
"is_worker_holiday": true,
"day": "string"
}
]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Holidays |
Renders a list of subsidiary holidays
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays
Renders a list of subsidiary holidays...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
subsidiary_id | path | string | true | subsidiary id |
Example responses
200 Response
[
{
"recurrent_until": "string",
"recurrent": "string",
"name": "string",
"is_worker_holiday": true,
"day": "string"
}
]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Holidays |
Lists communication messages
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id?send_at=string \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id?send_at=string HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id?send_at=string',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id',
params: {
'send_at' => 'string'
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id', params={
'send_at': 'string'
}, headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id?send_at=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_communication/:communication_id", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/:company_id/communications/messages/by_communication/:communication_id
Lists communication messages
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
communication_id | path | string | true | communication id |
send_at | query | string | true | send_at |
page | query | integer | false | page number |
page_size | query | integer | false | number of results per page |
opened | query | boolean | false | filter opened messages |
actions | query | boolean | false | filter messages with action_done |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | CommunicationMessages |
401 | Unauthorized | Unauthorized | Unauthorized |
Disables a company
Code samples
# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/{company_id} \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
PUT https://api.fluida.io/api/v1/companies/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}',
{
method: 'PUT',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.put 'https://api.fluida.io/api/v1/companies/{company_id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.put('https://api.fluida.io/api/v1/companies/{company_id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('PUT','https://api.fluida.io/api/v1/companies/{company_id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/{company_id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
PUT /api/v1/companies/{company_id}
Disables a company...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Renders a company for a given id
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id} \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}
Renders a company for a given id...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
Example responses
200 Response
{
"zip": "92328",
"vat": "123456789-0",
"trial_expiration_date": "2019-07-30T00:00:00Z",
"timezone": "Europe/Rome",
"subscription_status": "active",
"subscription_plan": "started",
"subscription_id": "1t0Aw18RVMhQ1Z2ELK",
"subscription_expiration_date": "2019-09-30T00:00:00Z",
"subscription_customer_id": "1t0Aw18RVMhQ1Z2ELK",
"subscribed_features": [
"export"
],
"province": "TO",
"preferences": {
"stamping_enabled": "true"
},
"plan_quantity": 10,
"phone": "07881 836703",
"pec": "foo.bar@pec.it",
"number_of_employees": 20,
"name": "Marks-Kemmer",
"location_info": {
"long": "0",
"lat": "43"
},
"id": "cbf4e570-7415-4f35-96f1-5e63000a1c3b",
"fiscal_code": "ABCDEF12A01H501-1",
"country": "Lithuania",
"codice_destinatario": "000000",
"city": "Ritchieberg",
"billing_email": "billing-1@example.com",
"admin_user_id": "ca344b9d-c0ec-4e18-b528-cea10431c7cd",
"admin_user_email": "company-admin-0@example.com",
"address": "14138 Cummerata Brooks"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Company |
Adds a contract to a list of teams
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"team_ids": [
"string"
],
"contract_id": "string"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/add_to_teams", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies/{company_id}/contracts/{id}/add_to_teams
Adds a contract to a list of teams...
Body parameter
{
"team_ids": [
"string"
],
"contract_id": "string"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
id | path | string | true | team id |
body | body | ContractTeamsParams | false | team attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Lists communication messages by contract
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/:company_id/communications/messages/by_contract/:contract_id
Lists communication messages by contract
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
contract_id | path | string | true | contract id |
page | query | integer | false | page number |
page_size | query | integer | false | number of results per page |
opened | query | boolean | false | filter opened messages |
year | query | integer | false | filter messages by year |
actions | query | boolean | false | filter messages with action_done |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | CommunicationMessages |
401 | Unauthorized | Unauthorized | Unauthorized |
Adds a weekly closing day to subsidiary
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"weekday": "string"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days
Adds a weekly closing day to subsidiary...
Body parameter
{
"weekday": "string"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
subsidiary_id | path | string | true | subsidiary id |
body | body | Weekday | true | weekday |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Renders a list of subsidiary weekly closing days for a given subsidiary id
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days
Renders a list of subsidiary weekly closing days for a given subsidiary id...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
subsidiary_id | path | string | true | subsidiary id |
Example responses
200 Response
{
"weekday": "string",
"subsidiary_id": "string",
"company_id": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | SubsidiaryWeeklyClosingDays |
Creates a notification for holiday import
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/holiday_from_bulk \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies/{company_id}/holiday_from_bulk HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/holiday_from_bulk',
{
method: 'POST',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/holiday_from_bulk',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/holiday_from_bulk', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/holiday_from_bulk', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/holiday_from_bulk");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/holiday_from_bulk", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies/{company_id}/holiday_from_bulk
Creates a notification for holiday import...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
List fluida extensions related to a company
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/extensions \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/:company_id/extensions HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/extensions',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/extensions',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/extensions', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/extensions', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/extensions");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/extensions", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/:company_id/extensions
List fluida extensions related to a company...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
category | path | string | true | company_id |
enabled | query | boolean | false | filter by enabled |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | CompanyExtensions |
401 | Unauthorized | Unauthorized | Unauthorized |
Gets a company communication attachment
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/companies/:company_id/communications/attachments/by_contract/:contract_id/:id", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /companies/:company_id/communications/attachments/by_contract/:contract_id/:id
Gets a company communication attachment...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
contract_id | path | string | true | contract id |
id | path | string | true | attachment id |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Avatar |
Creates a company
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"zip": "92328",
"vat": "123456789-0",
"trial_expiration_date": "2019-07-30T00:00:00Z",
"timezone": "Europe/Rome",
"subscription_status": "active",
"subscription_plan": "started",
"subscription_id": "1t0Aw18RVMhQ1Z2ELK",
"subscription_expiration_date": "2019-09-30T00:00:00Z",
"subscription_customer_id": "1t0Aw18RVMhQ1Z2ELK",
"subscribed_features": [
"export"
],
"province": "TO",
"preferences": {
"stamping_enabled": "true"
},
"plan_quantity": 10,
"phone": "07881 836703",
"pec": "foo.bar@pec.it",
"number_of_employees": 20,
"name": "Marks-Kemmer",
"location_info": {
"long": "0",
"lat": "43"
},
"id": "cbf4e570-7415-4f35-96f1-5e63000a1c3b",
"fiscal_code": "ABCDEF12A01H501-1",
"country": "Lithuania",
"codice_destinatario": "000000",
"city": "Ritchieberg",
"billing_email": "billing-1@example.com",
"admin_user_id": "ca344b9d-c0ec-4e18-b528-cea10431c7cd",
"admin_user_email": "company-admin-0@example.com",
"address": "14138 Cummerata Brooks"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies
Creates a company...
Body parameter
{
"zip": "92328",
"vat": "123456789-0",
"trial_expiration_date": "2019-07-30T00:00:00Z",
"timezone": "Europe/Rome",
"subscription_status": "active",
"subscription_plan": "started",
"subscription_id": "1t0Aw18RVMhQ1Z2ELK",
"subscription_expiration_date": "2019-09-30T00:00:00Z",
"subscription_customer_id": "1t0Aw18RVMhQ1Z2ELK",
"subscribed_features": [
"export"
],
"province": "TO",
"preferences": {
"stamping_enabled": "true"
},
"plan_quantity": 10,
"phone": "07881 836703",
"pec": "foo.bar@pec.it",
"number_of_employees": 20,
"name": "Marks-Kemmer",
"location_info": {
"long": "0",
"lat": "43"
},
"id": "cbf4e570-7415-4f35-96f1-5e63000a1c3b",
"fiscal_code": "ABCDEF12A01H501-1",
"country": "Lithuania",
"codice_destinatario": "000000",
"city": "Ritchieberg",
"billing_email": "billing-1@example.com",
"admin_user_id": "ca344b9d-c0ec-4e18-b528-cea10431c7cd",
"admin_user_email": "company-admin-0@example.com",
"address": "14138 Cummerata Brooks"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
body | body | Company | false | company attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Removes a contract from a team
Code samples
# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id} \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
DELETE https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}',
{
method: 'DELETE',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
DELETE /api/v1/companies/{company_id}/teams/{team_id}/remove_contract/{contract_id}
Removes a contract from a team...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
team_id | path | string | true | team id |
contract_id | path | string | true | contract id |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Get company extension
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/extension/:extension_id", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/:company_id/extension/:extension_id
Get company extension...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company_id |
extension_id | path | string | true | extension_id |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | CompanyExtension |
401 | Unauthorized | Unauthorized | Unauthorized |
Removes a weekly closing day from company
Code samples
# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id} \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
DELETE https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}',
{
method: 'DELETE',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
DELETE /api/v1/companies/{company_id}/weekly_closing_days/{id}
Removes a weekly closing day from company...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
id | path | string | true | weekday id |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Adds a weekly closing day to company
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"weekday": "string"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies/{company_id}/weekly_closing_days
Adds a weekly closing day to company...
Body parameter
{
"weekday": "string"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
body | body | Weekday | true | weekday |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Renders a list of weekly closing days for a given company id
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/weekly_closing_days", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/weekly_closing_days
Renders a list of weekly closing days for a given company id...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
Example responses
200 Response
{
"weekday": "string",
"company_id": "string"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | CompanyWeeklyClosingDays |
Puts a company communication attachment
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"avatar": {}
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/:company_id/communications/:communication_id/attachments", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies/:company_id/communications/:communication_id/attachments
Puts a company communication attachment...
Body parameter
{
"avatar": {}
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
communication_id | path | string | true | communication id |
body | body | Avatar | true | document attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Creates a subsidiary for a given company
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"zip": "61290",
"timezone": "Europe/Rome",
"ref_code": "12390193",
"province": "South",
"name": "Thompson-Emard",
"location_info": {
"long": "0",
"lat": "43"
},
"country": "Spain",
"company_id": "8beeb818-a837-473a-bb55-a935720b6686",
"city": "Port Holdenville",
"capacity": 4,
"address": "47395 Gus Unions"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies/{company_id}/subsidiaries
Creates a subsidiary for a given company...
Body parameter
{
"zip": "61290",
"timezone": "Europe/Rome",
"ref_code": "12390193",
"province": "South",
"name": "Thompson-Emard",
"location_info": {
"long": "0",
"lat": "43"
},
"country": "Spain",
"company_id": "8beeb818-a837-473a-bb55-a935720b6686",
"city": "Port Holdenville",
"capacity": 4,
"address": "47395 Gus Unions"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
body | body | Subsidiary | false | subsidiary attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Renders a list of subsidiaries for a given company id
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/subsidiaries
Renders a list of subsidiaries for a given company id...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
name | query | string | false | subsidiary name |
Example responses
200 Response
[
{
"zip": "61290",
"timezone": "Europe/Rome",
"ref_code": "12390193",
"province": "South",
"name": "Thompson-Emard",
"location_info": {
"long": "0",
"lat": "43"
},
"country": "Spain",
"company_id": "8beeb818-a837-473a-bb55-a935720b6686",
"city": "Port Holdenville",
"capacity": 4,
"address": "47395 Gus Unions"
}
]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Subsidiaries |
Creates a company api key
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/api_keys \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies/{company_id}/api_keys HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"type": "full",
"scopes": [],
"name": "Full access api"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/api_keys',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/api_keys', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/api_keys', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/api_keys");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/api_keys", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies/{company_id}/api_keys
Creates a company api key...
Body parameter
{
"type": "full",
"scopes": [],
"name": "Full access api"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
body | body | ApiKey | false | api key attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
List company api keys
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/api_keys \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/api_keys HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/api_keys',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/api_keys', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/api_keys', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/api_keys");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/api_keys", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/api_keys
List company api keys...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | ApiKeys |
401 | Unauthorized | Unauthorized | Unauthorized |
Renders a timesheet company summary
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/timesheet_summary", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/timesheet_summary
Renders a timesheet company summary
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
contract_id | query | string | false | Contract id |
team_ids | query | array[string] | false | Team Ids |
subsidiary_ids | query | array[string] | false | Subsidiary Ids |
start_date | query | string | false | Start date |
end_date | query | string | false | End date |
Example responses
200 Response
[]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Summary |
Removes a weekly closing day from subsidiary
Code samples
# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id} \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
DELETE https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}',
{
method: 'DELETE',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
DELETE /api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/subsidiary_weekly_closing_days/{id}
Removes a weekly closing day from subsidiary...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
subsidiary_id | path | string | true | subsidiary id |
id | path | string | true | weekday id |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Updates a subsidiary for a given company
Code samples
# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id} \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
PUT https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"zip": "61290",
"timezone": "Europe/Rome",
"ref_code": "12390193",
"province": "South",
"name": "Thompson-Emard",
"location_info": {
"long": "0",
"lat": "43"
},
"country": "Spain",
"company_id": "8beeb818-a837-473a-bb55-a935720b6686",
"city": "Port Holdenville",
"capacity": 4,
"address": "47395 Gus Unions"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id}',
{
method: 'PUT',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.put 'https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.put('https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('PUT','https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/:company_id/subsidiaries/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
PUT /api/v1/companies/:company_id/subsidiaries/{id}
Updates a subsidiary for a given company...
Body parameter
{
"zip": "61290",
"timezone": "Europe/Rome",
"ref_code": "12390193",
"province": "South",
"name": "Thompson-Emard",
"location_info": {
"long": "0",
"lat": "43"
},
"country": "Spain",
"company_id": "8beeb818-a837-473a-bb55-a935720b6686",
"city": "Port Holdenville",
"capacity": 4,
"address": "47395 Gus Unions"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
id | path | string | true | subsidiary id |
body | body | Subsidiary | false | subsidiary attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Renders a subsidiary for a given company id
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id} \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/subsidiaries/{id}
Renders a subsidiary for a given company id...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
id | path | string | true | subsidiary id |
Example responses
200 Response
{
"zip": "61290",
"timezone": "Europe/Rome",
"ref_code": "12390193",
"province": "South",
"name": "Thompson-Emard",
"location_info": {
"long": "0",
"lat": "43"
},
"country": "Spain",
"company_id": "8beeb818-a837-473a-bb55-a935720b6686",
"city": "Port Holdenville",
"capacity": 4,
"address": "47395 Gus Unions"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Subsidiary |
Deletes a subsidiary for a given company
Code samples
# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id} \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
DELETE https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}',
{
method: 'DELETE',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
DELETE /api/v1/companies/{company_id}/subsidiaries/{id}
Deletes a subsidiary for a given company...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
id | path | string | true | subsidiary id |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Renders a list of holidays by dates
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/subsidiaries/{subsidiary_id}/holidays_by_dates
Renders a list of holidays between two dates
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
subsidiary_id | path | string | true | subsidiary id |
start_date | query | string | false | Start date |
end_date | query | string | false | End date |
Example responses
200 Response
[
{
"recurrent_until": "string",
"recurrent": "string",
"name": "string",
"is_worker_holiday": true,
"day": "string"
}
]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Holidays |
Renders a team for a given company id
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/teams/{id} \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/teams/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/teams/{id}
Renders a team for a given company id...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
id | path | string | true | team id |
Example responses
200 Response
{
"team_leader_ids": [
"46568afb-1eab-447b-9289-c7ca989fbbe7",
"8bc89469-9cb9-45fa-bd5d-0fd3460faab6"
],
"subsidiary_id": "e6eefd3e-4e07-47f2-841c-9f1e7a2a527b",
"name": "Thompson-Emard",
"company_id": "1779ce91-de0e-4cc4-83fe-a62f7fac62de",
"code": "47395 Gus Unions"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Team |
Deletes a team for a given company
Code samples
# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/teams/{id} \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
DELETE https://api.fluida.io/api/v1/companies/{company_id}/teams/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}',
{
method: 'DELETE',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
DELETE /api/v1/companies/{company_id}/teams/{id}
Deletes a team for a given company...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
id | path | string | true | team id |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Adds a contract to a team
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"team_id": "string",
"contract_id": "string"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/teams/{team_id}/add_contract", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies/{company_id}/teams/{team_id}/add_contract
Adds a contract to a team...
Body parameter
{
"team_id": "string",
"contract_id": "string"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
team_id | path | string | true | team id |
body | body | ContractTeamParams | false | team attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Creates a missing approver notification
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver',
{
method: 'POST',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/companies/{company_id}/contracts/{id}/missing_approver", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/companies/{company_id}/contracts/{id}/missing_approver
Creates a missing approver notification...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
id | path | string | true | contract id |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Updates a communication message
Code samples
# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
PUT https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"opened": true,
"action_done_at": "string",
"action_done": "string"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id',
{
method: 'PUT',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.put 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.put('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('PUT','https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
PUT /api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id
Updates a communication message...
Body parameter
{
"opened": true,
"action_done_at": "string",
"action_done": "string"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
id | path | string | true | communication_message id |
company_id | path | string | true | company id |
contract_id | path | string | true | company id |
body | body | CommunicationMessageAction | false | communication message |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Shows a communication message
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/:company_id/communications/messages/by_contract/:contract_id/:id
Shows a communication message...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
id | path | string | true | communication message id |
contract_id | path | string | true | contract id |
company_id | path | string | true | company id |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | CommunicationMessage |
401 | Unauthorized | Unauthorized | Unauthorized |
Updates a company api key
Code samples
# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id} \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
PUT https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = '{
"type": "full",
"scopes": [],
"name": "Full access api"
}';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
{
method: 'PUT',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.put 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.put('https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('PUT','https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
PUT /api/v1/companies/{company_id}/api_keys/{id}
Updates a company api key...
Body parameter
{
"type": "full",
"scopes": [],
"name": "Full access api"
}
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
id | path | string | true | api key id |
body | body | ApiKey | false | api key attributes |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Gets a company api key
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id} \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/companies/{company_id}/api_keys/{id}
Gets a company api key...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
api_key_id | path | string | true | api key id |
Example responses
200 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | ApiKey |
401 | Unauthorized | Unauthorized | Unauthorized |
Deletes a company api key
Code samples
# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id} \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
DELETE https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*
const headers = {
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
{
method: 'DELETE',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.delete 'https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('DELETE','https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/companies/{company_id}/api_keys/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
DELETE /api/v1/companies/{company_id}/api_keys/{id}
Deletes a company api key...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
id | path | string | true | api key id |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Request
Renders a set of approvers by entity and contract
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id} \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id}',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/requests/{company_id}/{entity_type}/approvers/by_contract/{contract_id}
Renders a set of approvers by entity and contract...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
entity_type | path | string | true | entity type |
contract_id | path | string | true | contract id |
Example responses
200 Response
{
"approver_ids": [
"ca83b036-04cc-48df-a367-d6375b94ddcd"
]
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Approvers |
Renders a request by entity
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/entity_id \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/entity_id HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/entity_id',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/entity_id',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/entity_id', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/entity_id', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/entity_id");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/entity_id", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/requests/{company_id}/{entity_type}/entity_id
Renders a request by entity...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
entity_type | path | string | true | entity type |
entity_id | path | string | true | entity id |
Example responses
200 Response
{
"id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
"entity_type": "justification",
"entity_id": "ddbb23bb-1cbe-48ce-bd55-43908e623e1f",
"entity_data": {
"type_name": "adipisci",
"type_label": "quia",
"type_id": "holiday",
"to_time": "12:00:00",
"to_date": "2019-03-02",
"status": "requested",
"notes": "Quisquam atque impedit accusantium consequatur sint distinctio aut est explicabo.",
"id": "e508bd7c-aa20-4cfc-a179-e2324b416e29",
"from_time": "10:00:00",
"from_date": "2019-02-26",
"followers_ids": [
"c1f86232-2dfb-42a5-aff0-65521a3a01ac",
"e80ee330-aa3a-4f8d-be8f-748869705b5d"
],
"contract_id": "90725746-5c2d-44fc-908f-96e50f8e65ba",
"approvers_ids": [
"13d2371a-326d-4b96-912f-c20f2c2cef15"
]
},
"contract_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2"
}
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Request |
Approves a request
Code samples
# You can also use wget
curl -X POST https://api.fluida.io/api/v1/requests/{id}/approve \
-H 'Content-Type: application/json' \
-H 'Accept: */*' \
-H 'Authorization: Bearer {access-token}'
POST https://api.fluida.io/api/v1/requests/{id}/approve HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*
const inputBody = 'false';
const headers = {
'Content-Type':'application/json',
'Accept':'*/*',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/requests/{id}/approve',
{
method: 'POST',
body: inputBody,
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.post 'https://api.fluida.io/api/v1/requests/{id}/approve',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Content-Type': 'application/json',
'Accept': '*/*',
'Authorization': 'Bearer {access-token}'
}
r = requests.post('https://api.fluida.io/api/v1/requests/{id}/approve', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Content-Type' => 'application/json',
'Accept' => '*/*',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('POST','https://api.fluida.io/api/v1/requests/{id}/approve', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/requests/{id}/approve");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Content-Type": []string{"application/json"},
"Accept": []string{"*/*"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/requests/{id}/approve", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
POST /api/v1/requests/{id}/approve
Approves a request...
Body parameter
false
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
id | path | string | true | request id |
Example responses
401 Response
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
202 | Accepted | Accepted | None |
401 | Unauthorized | Unauthorized | Unauthorized |
Renders a list of requests for an approver contract
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/requests/{company_id}/by_approver/{approver_contract_id} \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/requests/{company_id}/by_approver/{approver_contract_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/requests/{company_id}/by_approver/{approver_contract_id}',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/requests/{company_id}/by_approver/{approver_contract_id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/requests/{company_id}/by_approver/{approver_contract_id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/requests/{company_id}/by_approver/{approver_contract_id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/requests/{company_id}/by_approver/{approver_contract_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/requests/{company_id}/by_approver/{approver_contract_id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}
GET /api/v1/requests/{company_id}/by_approver/{approver_contract_id}
Renders a list of requests for an approver_contract...
Parameters
Name | In | Type | Required | Description |
---|---|---|---|---|
company_id | path | string | true | company id |
approver_contract_id | path | string | true | approver contract id |
Example responses
200 Response
[
{
"id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
"entity_type": "justification",
"entity_id": "ddbb23bb-1cbe-48ce-bd55-43908e623e1f",
"entity_data": {
"type_name": "adipisci",
"type_label": "quia",
"type_id": "holiday",
"to_time": "12:00:00",
"to_date": "2019-03-02",
"status": "requested",
"notes": "Quisquam atque impedit accusantium consequatur sint distinctio aut est explicabo.",
"id": "e508bd7c-aa20-4cfc-a179-e2324b416e29",
"from_time": "10:00:00",
"from_date": "2019-02-26",
"followers_ids": [
"c1f86232-2dfb-42a5-aff0-65521a3a01ac",
"e80ee330-aa3a-4f8d-be8f-748869705b5d"
],
"contract_id": "90725746-5c2d-44fc-908f-96e50f8e65ba",
"approvers_ids": [
"13d2371a-326d-4b96-912f-c20f2c2cef15"
]
},
"contract_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2"
}
]
Responses
Status | Meaning | Description | Schema |
---|---|---|---|
200 | OK | Success | Requests |
Renders a request
Code samples
# You can also use wget
curl -X GET https://api.fluida.io/api/v1/requests/{company_id}/{id} \
-H 'Accept: application/json' \
-H 'Authorization: Bearer {access-token}'
GET https://api.fluida.io/api/v1/requests/{company_id}/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json
const headers = {
'Accept':'application/json',
'Authorization':'Bearer {access-token}'
};
fetch('https://api.fluida.io/api/v1/requests/{company_id}/{id}',
{
method: 'GET',
headers: headers
})
.then(function(res) {
return res.json();
}).then(function(body) {
console.log(body);
});
require 'rest-client'
require 'json'
headers = {
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}'
}
result = RestClient.get 'https://api.fluida.io/api/v1/requests/{company_id}/{id}',
params: {
}, headers: headers
p JSON.parse(result)
import requests
headers = {
'Accept': 'application/json',
'Authorization': 'Bearer {access-token}'
}
r = requests.get('https://api.fluida.io/api/v1/requests/{company_id}/{id}', headers = headers)
print(r.json())
<?php
require 'vendor/autoload.php';
$headers = array(
'Accept' => 'application/json',
'Authorization' => 'Bearer {access-token}',
);
$client = new \GuzzleHttp\Client();
// Define array of request body.
$request_body = array();
try {
$response = $client->request('GET','https://api.fluida.io/api/v1/requests/{company_id}/{id}', array(
'headers' => $headers,
'json' => $request_body,
)
);
print_r($response->getBody()->getContents());
}
catch (\GuzzleHttp\Exception\BadResponseException $e) {
// handle exception or api errors.
print_r($e->getMessage());
}
// ...
URL obj = new URL("https://api.fluida.io/api/v1/requests/{company_id}/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
System.out.println(response.toString());
package main
import (
"bytes"
"net/http"
)
func main() {
headers := map[string][]string{
"Accept": []string{"application/json"},
"Authorization": []string{"Bearer {access-token}"},
}
data := bytes.NewBuffer([]byte{jsonReq})
req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/requests/{company_id}/{id}", data)
req.Header = headers
client := &http.Client{}
resp, err := client.Do(req)
// ...
}