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:

• https://api.fluida.io

Terms of service

Authentication

• API Key (ApiKey)

  • Parameter Name: x-fluida-app-uuid, in: header. Api Key for authorized app

• oAuth2 authentication.

  • Flow: implicit
  • Authorization URL = https://app.fluida.io/oauth/authorize

Scope	Scope Description
write:contract_day_schedule_change	Contract day schedule change write
read:holiday	Holiday read
write:expense	Expense write
write:export	Export write
read:export	Export read
read:expense_type	Expense type read
read:activity	Activity read
write:orders	Orders write
read:schedule	Schedule read
write:holiday	Holiday write
read:calendar	Calendar read
read:activity_types	Activity types read
write:justification	Justification write
read:justification	Justification read
read:justification_type	Justification type read
write:workplace_override	Workplace override write
write:stamping_device	Stamping device write
read:stamping_device	Stamping device read
read:company	Company read
write:justification_type	Justification type write
write:company_communication	Company communication write
read:company_communication	Company communication read
read:stamping_area	Stamping area read
read:stamping	Stamping read
read:activities	Activities read
write:stamping	Stamping write
read:contract	Contract read
write:activity	Activity write
read:customer	Customer read
write:customer	Customer write
read:activity_type	Activity type read
write:team	Team write
write:activity_types	Activity types write
read:team	Team read
read:customers	Customers read
write:schedule	Schedule write
read:workplace_override	Workplace override read
read:request	Request read
write:company_communication_message	Company communication message write
read:expense_report	Expense report read
read:order	Order read
write:contract	Contract write
read:contract_day_schedule_change	Contract day schedule change read
read:orders	Orders read
write:activities	Activities write
read:expense	Expense read
write:expense_report	Expense report write
write:customers	Customers write
read:company_communication_message	Company communication message read
read:user_document	User document read
write:order	Order write
write:user_document	User document write
write:stamping_area	Stamping area write
write:activity_type	Activity type write
write:expense_type	Expense type write
write:request	Request write
write:company	Company write

Activity

Creates an activity and a daily schedule for the day and min_to_report at 0 if it doesn't exist

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/activities/activity \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/activities/activity HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/activities/activity', headers = headers)

print(r.json())

const inputBody = '{
  "activity_type_id": "string",
  "attachment_ids": [
    "string"
  ],
  "company_id": "string",
  "contract_id": "string",
  "date": "string",
  "duration": 0,
  "location": {},
  "location_datetime": "string",
  "location_lat": 0,
  "location_lng": 0,
  "notes": "string",
  "order_id": "string",
  "picture_id": "string",
  "team_ids": [
    "string"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/activities/activity', 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/activities/activity");
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/activities/activity", data)
    req.Header = headers

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

POST /api/v1/activities/activity

Creates an activity and a daily schedule for the and min_to_report day at 0 if it doesn't exist

Body parameter

{
  "activity_type_id": "string",
  "attachment_ids": [
    "string"
  ],
  "company_id": "string",
  "contract_id": "string",
  "date": "string",
  "duration": 0,
  "location": {},
  "location_datetime": "string",
  "location_lat": 0,
  "location_lng": 0,
  "notes": "string",
  "order_id": "string",
  "picture_id": "string",
  "team_ids": [
    "string"
  ]
}

Parameters

Name	In	Type	Required	Description
body	body	Activity	false	Activity attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Query for activities

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/activities/activity/company/{company_id}/aggregate/{first_level}/{second_level} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/activities/activity/company/{company_id}/aggregate/{first_level}/{second_level} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/activities/activity/company/{company_id}/aggregate/{first_level}/{second_level}', headers = headers)

print(r.json())

const inputBody = '{
  "activity_type_ids": [
    "string"
  ],
  "contract_ids": [
    "string"
  ],
  "end_date": "string",
  "start_date": "string",
  "team_ids": [
    "string"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/company/{company_id}/aggregate/{first_level}/{second_level}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/activities/activity/company/{company_id}/aggregate/{first_level}/{second_level}', 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/activities/activity/company/{company_id}/aggregate/{first_level}/{second_level}");
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/activities/activity/company/{company_id}/aggregate/{first_level}/{second_level}", data)
    req.Header = headers

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

POST /api/v1/activities/activity/company/{company_id}/aggregate/{first_level}/{second_level}

Query for activities

Body parameter

{
  "activity_type_ids": [
    "string"
  ],
  "contract_ids": [
    "string"
  ],
  "end_date": "string",
  "start_date": "string",
  "team_ids": [
    "string"
  ]
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company id
first_level	path	string	true	First level
second_level	path	string	true	Second level
body	body	ActivityFilters	false	Filters

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
200	OK	Ok	None
401	Unauthorized	Unauthorized	Unauthorized

Returns a data structure with minutes to report, reported and difference for each contract the given contract is able to read

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/activity/report_minutes_not_completed/readable/company/{company_id}/from/{from}/to/{to} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/activity/report_minutes_not_completed/readable/company/{company_id}/from/{from}/to/{to} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/activity/report_minutes_not_completed/readable/company/{company_id}/from/{from}/to/{to}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/report_minutes_not_completed/readable/company/{company_id}/from/{from}/to/{to}',
{
  method: 'GET',

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

<?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/activities/activity/report_minutes_not_completed/readable/company/{company_id}/from/{from}/to/{to}', 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/activities/activity/report_minutes_not_completed/readable/company/{company_id}/from/{from}/to/{to}");
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/activities/activity/report_minutes_not_completed/readable/company/{company_id}/from/{from}/to/{to}", data)
    req.Header = headers

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

GET /api/v1/activities/activity/report_minutes_not_completed/readable/company/{company_id}/from/{from}/to/{to}

Returns a data structure with minutes to report, reported and difference for each contract the given contract is able to read

Parameters

Name	In	Type	Required	Description
from	path	string	true	Start Date
to	path	string	true	End Date
company_id	path	string	true	Company id
contract_ids	query	string	false	Contract ids to filter by
team_ids	query	string	false	Team ids to filter by

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ReportTotMinDailySchedule
401	Unauthorized	Unauthorized	Unauthorized

Returns activities of a specific company

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/activity/reported/{company_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/activity/reported/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/activity/reported/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/reported/{company_id}',
{
  method: 'GET',

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

<?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/activities/activity/reported/{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/activities/activity/reported/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/activities/activity/reported/{company_id}", data)
    req.Header = headers

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

GET /api/v1/activities/activity/reported/{company_id}

Returns activities of a specific company

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company ID
date	query	string	false	Date
deleted	query	boolean	false	Return even if deleted

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ActivityReport
401	Unauthorized	Unauthorized	Unauthorized

List contract activities

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/activity/reported/{company_id}/{contract_id}/{date} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/activity/reported/{company_id}/{contract_id}/{date} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/activity/reported/{company_id}/{contract_id}/{date}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/reported/{company_id}/{contract_id}/{date}',
{
  method: 'GET',

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

<?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/activities/activity/reported/{company_id}/{contract_id}/{date}', 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/activities/activity/reported/{company_id}/{contract_id}/{date}");
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/activities/activity/reported/{company_id}/{contract_id}/{date}", data)
    req.Header = headers

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

GET /api/v1/activities/activity/reported/{company_id}/{contract_id}/{date}

Returns activities of a specific contract for a specific date

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company ID
contract_id	path	string	true	Contract ID
date	path	string	true	Date
deleted	query	boolean	false	Return even if deleted

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ActivityReport
401	Unauthorized	Unauthorized	Unauthorized

Returns a data structure with dates and minutes reported and to report

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/per/{contract_id}/from/{from}/to/{to} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/per/{contract_id}/from/{from}/to/{to} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/per/{contract_id}/from/{from}/to/{to}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/per/{contract_id}/from/{from}/to/{to}',
{
  method: 'GET',

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

<?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/activities/activity/schedules_not_completed/per/{contract_id}/from/{from}/to/{to}', 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/activities/activity/schedules_not_completed/per/{contract_id}/from/{from}/to/{to}");
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/activities/activity/schedules_not_completed/per/{contract_id}/from/{from}/to/{to}", data)
    req.Header = headers

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

GET /api/v1/activities/activity/schedules_not_completed/per/{contract_id}/from/{from}/to/{to}

Returns a data structure with dates and minutes reported and to report

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	Contract ID
from	path	string	true	Start Date
to	path	string	true	End Date

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ScheduleNotCompleted
401	Unauthorized	Unauthorized	Unauthorized

Returns a data structure with dates and minutes reported and to report for each contract the given contract is able to read

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/readable/company/{company_id}/from/{from}/to/{to} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/readable/company/{company_id}/from/{from}/to/{to} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/readable/company/{company_id}/from/{from}/to/{to}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/readable/company/{company_id}/from/{from}/to/{to}',
{
  method: 'GET',

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

<?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/activities/activity/schedules_not_completed/readable/company/{company_id}/from/{from}/to/{to}', 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/activities/activity/schedules_not_completed/readable/company/{company_id}/from/{from}/to/{to}");
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/activities/activity/schedules_not_completed/readable/company/{company_id}/from/{from}/to/{to}", data)
    req.Header = headers

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

GET /api/v1/activities/activity/schedules_not_completed/readable/company/{company_id}/from/{from}/to/{to}

Returns a data structure with dates and minutes reported and to report for each contract the given contract is able to read

Parameters

Name	In	Type	Required	Description
from	path	string	true	Start Date
to	path	string	true	End Date
company_id	path	string	true	Company id
contract_ids	query	string	false	Contract ids to filter by
team_ids	query	string	false	Team ids to filter by

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ScheduleNotCompleted
401	Unauthorized	Unauthorized	Unauthorized

Returns a list of the most reported activities limited to a certain number

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/activity/suggested/{contract_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/activity/suggested/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/activity/suggested/{contract_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/suggested/{contract_id}',
{
  method: 'GET',

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

<?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/activities/activity/suggested/{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/activities/activity/suggested/{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/activities/activity/suggested/{contract_id}", data)
    req.Header = headers

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

GET /api/v1/activities/activity/suggested/{contract_id}

Returns a list of the most reported activities limited to a certain number

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	Contract ID
deleted	query	boolean	false	Return even if deleted

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ActivityTypesAndOrders
401	Unauthorized	Unauthorized	Unauthorized

Deletes an activity

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/activities/activity/{activity_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/activities/activity/{activity_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/activities/activity/{activity_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/{activity_id}',
{
  method: 'DELETE',

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

<?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/activities/activity/{activity_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/activities/activity/{activity_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/activities/activity/{activity_id}", data)
    req.Header = headers

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

DELETE /api/v1/activities/activity/{activity_id}

Deletes an activity

Parameters

Name	In	Type	Required	Description
activity_id	path	string	true	Activity ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Get Activity by ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/activity/{activity_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/activity/{activity_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/activity/{activity_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/{activity_id}',
{
  method: 'GET',

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

<?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/activities/activity/{activity_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/activities/activity/{activity_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/activities/activity/{activity_id}", data)
    req.Header = headers

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

GET /api/v1/activities/activity/{activity_id}

Get Activity by ID

Parameters

Name	In	Type	Required	Description
activity_id	path	string	true	Activity ID
deleted	query	boolean	false	Return even if deleted

Example responses

200 Response

{
  "activity_type_id": "string",
  "attachment_ids": [
    "string"
  ],
  "company_id": "string",
  "contract_id": "string",
  "date": "string",
  "duration": 0,
  "location": {},
  "location_datetime": "string",
  "location_lat": 0,
  "location_lng": 0,
  "notes": "string",
  "order_id": "string",
  "picture_id": "string",
  "team_ids": [
    "string"
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Activity
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Updates an activity

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/activities/activity/{activity_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/activities/activity/{activity_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/activities/activity/{activity_id}', headers = headers)

print(r.json())

const inputBody = '{
  "activity_type_id": "string",
  "attachment_ids": [
    "string"
  ],
  "company_id": "string",
  "contract_id": "string",
  "date": "string",
  "duration": 0,
  "location": {},
  "location_datetime": "string",
  "location_lat": 0,
  "location_lng": 0,
  "notes": "string",
  "order_id": "string",
  "picture_id": "string",
  "team_ids": [
    "string"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/{activity_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/activities/activity/{activity_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/activities/activity/{activity_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/activities/activity/{activity_id}", data)
    req.Header = headers

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

PUT /api/v1/activities/activity/{activity_id}

Updates an activity

Body parameter

{
  "activity_type_id": "string",
  "attachment_ids": [
    "string"
  ],
  "company_id": "string",
  "contract_id": "string",
  "date": "string",
  "duration": 0,
  "location": {},
  "location_datetime": "string",
  "location_lat": 0,
  "location_lng": 0,
  "notes": "string",
  "order_id": "string",
  "picture_id": "string",
  "team_ids": [
    "string"
  ]
}

Parameters

Name	In	Type	Required	Description
activity_id	path	string	true	Activity ID
body	body	Activity	false	Activity attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Updates an activity with new attachments

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment HTTP/1.1
Host: api.fluida.io
Content-Type: application/x-www-form-urlencoded
Accept: */*

import requests
headers = {
  'Content-Type': 'application/x-www-form-urlencoded',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment', headers = headers)

print(r.json())

const inputBody = '{
  "document": "string"
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/x-www-form-urlencoded',
    '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/activities/activity/{activity_id}/attachment', 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/activities/activity/{activity_id}/attachment");
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/x-www-form-urlencoded"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment", data)
    req.Header = headers

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

PUT /api/v1/activities/activity/{activity_id}/attachment

Updates an activity with new attachments

Body parameter

document: string

Parameters

Name	In	Type	Required	Description
activity_id	path	string	true	Activity ID
body	body	object	false	none
» document	body	string(binary)	false	Attachment File

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Updates an activity removing an attachment

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id}',
{
  method: 'DELETE',

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

<?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/activities/activity/{activity_id}/attachment/{attachment_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/activities/activity/{activity_id}/attachment/{attachment_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/activities/activity/{activity_id}/attachment/{attachment_id}", data)
    req.Header = headers

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

DELETE /api/v1/activities/activity/{activity_id}/attachment/{attachment_id}

Updates an activity removing an attachment

Parameters

Name	In	Type	Required	Description
activity_id	path	string	true	Activity ID
attachment_id	path	string	true	Attachment ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Download an activity attachment

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id}',
{
  method: 'GET',

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

<?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/activities/activity/{activity_id}/attachment/{attachment_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/activities/activity/{activity_id}/attachment/{attachment_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/activities/activity/{activity_id}/attachment/{attachment_id}", data)
    req.Header = headers

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

GET /api/v1/activities/activity/{activity_id}/attachment/{attachment_id}

Download an activity attachment

Parameters

Name	In	Type	Required	Description
activity_id	path	string	true	Activity ID
attachment_id	path	string	true	Attachment ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
200	OK	file	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Updates an activity removing the picture

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture',
{
  method: 'DELETE',

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

<?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/activities/activity/{activity_id}/picture', 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/activities/activity/{activity_id}/picture");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    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/activities/activity/{activity_id}/picture", data)
    req.Header = headers

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

DELETE /api/v1/activities/activity/{activity_id}/picture

Updates an activity removing picture

Parameters

Name	In	Type	Required	Description
activity_id	path	string	true	Activity ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Updates an activity with new picture

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture HTTP/1.1
Host: api.fluida.io
Content-Type: application/x-www-form-urlencoded
Accept: */*

import requests
headers = {
  'Content-Type': 'application/x-www-form-urlencoded',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture', headers = headers)

print(r.json())

const inputBody = '{
  "document": "string"
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/x-www-form-urlencoded',
    '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/activities/activity/{activity_id}/picture', 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/activities/activity/{activity_id}/picture");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/x-www-form-urlencoded"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture", data)
    req.Header = headers

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

PUT /api/v1/activities/activity/{activity_id}/picture

Updates an activity with new picture

Body parameter

document: string

Parameters

Name	In	Type	Required	Description
activity_id	path	string	true	Activity ID
body	body	object	false	none
» document	body	string(binary)	false	Attachment File

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Download an activity picture

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture/{picture_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture/{picture_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture/{picture_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture/{picture_id}',
{
  method: 'GET',

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

<?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/activities/activity/{activity_id}/picture/{picture_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/activities/activity/{activity_id}/picture/{picture_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/activities/activity/{activity_id}/picture/{picture_id}", data)
    req.Header = headers

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

GET /api/v1/activities/activity/{activity_id}/picture/{picture_id}

Download an activity picture

Parameters

Name	In	Type	Required	Description
activity_id	path	string	true	Activity ID
picture_id	path	string	true	Picture ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
200	OK	file	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Creates an activity type

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/activities/activity_types \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/activities/activity_types HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/activities/activity_types', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string",
  "team_ids": [
    "string"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity_types',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/activities/activity_types', 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/activities/activity_types");
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/activities/activity_types", data)
    req.Header = headers

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

POST /api/v1/activities/activity_types

Creates an activity type

Body parameter

{
  "company_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string",
  "team_ids": [
    "string"
  ]
}

Parameters

Name	In	Type	Required	Description
body	body	ActivityType	false	ActivityType attributes

Example responses

201 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	ActivityType
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of Activity Types with a specific Company ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/activity_types/by_company/{company_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/activity_types/by_company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/activity_types/by_company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity_types/by_company/{company_id}',
{
  method: 'GET',

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

<?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/activities/activity_types/by_company/{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/activities/activity_types/by_company/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/activities/activity_types/by_company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/activities/activity_types/by_company/{company_id}

Renders a list of Activity Types with a specific Company ID

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	ActivityTypes
401	Unauthorized	Unauthorized	Unauthorized

Deletes an activity type

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}',
{
  method: 'DELETE',

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

<?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/activities/activity_types/{activity_type_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/activities/activity_types/{activity_type_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/activities/activity_types/{activity_type_id}", data)
    req.Header = headers

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

DELETE /api/v1/activities/activity_types/{activity_type_id}

Deletes an activity type

Parameters

Name	In	Type	Required	Description
activity_type_id	path	string	true	Activity Type ID

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ActivityType
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Get Activity Type by ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}',
{
  method: 'GET',

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

<?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/activities/activity_types/{activity_type_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/activities/activity_types/{activity_type_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/activities/activity_types/{activity_type_id}", data)
    req.Header = headers

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

GET /api/v1/activities/activity_types/{activity_type_id}

Get Activity Type by ID

Parameters

Name	In	Type	Required	Description
activity_type_id	path	string	true	Activity Type ID

Example responses

200 Response

{
  "company_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string",
  "team_ids": [
    "string"
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ActivityType
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Updates an activity type

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string",
  "team_ids": [
    "string"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/activities/activity_types/{activity_type_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/activities/activity_types/{activity_type_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/activities/activity_types/{activity_type_id}", data)
    req.Header = headers

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

PUT /api/v1/activities/activity_types/{activity_type_id}

Updates an activity type

Body parameter

{
  "company_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string",
  "team_ids": [
    "string"
  ]
}

Parameters

Name	In	Type	Required	Description
activity_type_id	path	string	true	Activity Type ID
body	body	ActivityType	false	ActivityType attributes

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ActivityType
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Creates a customer

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/activities/customers \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/activities/customers HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/activities/customers', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/customers',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/activities/customers', 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/activities/customers");
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/activities/customers", data)
    req.Header = headers

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

POST /api/v1/activities/customers

Creates a customer

Body parameter

{
  "company_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	Customer	false	Customer attributes

Example responses

201 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	Customer
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of Customers with a specific Company ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/customers/by_company/{company_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/customers/by_company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/customers/by_company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/customers/by_company/{company_id}',
{
  method: 'GET',

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

<?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/activities/customers/by_company/{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/activities/customers/by_company/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/activities/customers/by_company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/activities/customers/by_company/{company_id}

Renders a list of Customers with a specific Company ID

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company ID
disabled	query	boolean	false	Return even if disabled

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	Customers
401	Unauthorized	Unauthorized	Unauthorized

Deletes a Customer

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/activities/customers/{customer_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/activities/customers/{customer_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/activities/customers/{customer_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/customers/{customer_id}',
{
  method: 'DELETE',

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

<?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/activities/customers/{customer_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/activities/customers/{customer_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/activities/customers/{customer_id}", data)
    req.Header = headers

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

DELETE /api/v1/activities/customers/{customer_id}

Deletes a Customer

Parameters

Name	In	Type	Required	Description
customer_id	path	string	true	Customer ID

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	Customer
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Get Customer by ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/customers/{customer_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/customers/{customer_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/customers/{customer_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/customers/{customer_id}',
{
  method: 'GET',

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

<?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/activities/customers/{customer_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/activities/customers/{customer_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/activities/customers/{customer_id}", data)
    req.Header = headers

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

GET /api/v1/activities/customers/{customer_id}

Get Customer by ID

Parameters

Name	In	Type	Required	Description
customer_id	path	string	true	Customer ID
disabled	query	boolean	false	Return even if disabled

Example responses

200 Response

{
  "company_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Customer
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Updates a Customer

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/activities/customers/{customer_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/activities/customers/{customer_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/activities/customers/{customer_id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/customers/{customer_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/activities/customers/{customer_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/activities/customers/{customer_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/activities/customers/{customer_id}", data)
    req.Header = headers

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

PUT /api/v1/activities/customers/{customer_id}

Updates a Customer

Body parameter

{
  "company_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string"
}

Parameters

Name	In	Type	Required	Description
customer_id	path	string	true	Customer ID
body	body	Customer	false	Customer attributes

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	Customer
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Return the notes of a daily schedule

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes',
{
  method: 'GET',

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

<?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/activities/daily_schedule/date/{date}/contract/{contract_id}/notes', 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/activities/daily_schedule/date/{date}/contract/{contract_id}/notes");
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/activities/daily_schedule/date/{date}/contract/{contract_id}/notes", data)
    req.Header = headers

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

GET /api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes

Return the notes of a daily schedule

Parameters

Name	In	Type	Required	Description
date	path	string	true	Date
contract_id	path	string	true	Contract ID

Example responses

200 Response

{
  "notes": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Notes
401	Unauthorized	Unauthorized	Unauthorized

Updates a daily schedule with new notes

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes', headers = headers)

print(r.json())

const inputBody = '{
  "daily_schedule_id": "string",
  "notes": "string",
  "updated_by": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/activities/daily_schedule/date/{date}/contract/{contract_id}/notes', 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/activities/daily_schedule/date/{date}/contract/{contract_id}/notes");
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/activities/daily_schedule/date/{date}/contract/{contract_id}/notes", data)
    req.Header = headers

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

PUT /api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes

Updates a daily schedule with new notes

Body parameter

{
  "daily_schedule_id": "string",
  "notes": "string",
  "updated_by": "string"
}

Parameters

Name	In	Type	Required	Description
date	path	string	true	Date
contract_id	path	string	true	Contract ID
body	body	DailyScheduleNotes	false	New notes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Creates an Order

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/activities/orders \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/activities/orders HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/activities/orders', headers = headers)

print(r.json())

const inputBody = '{
  "customer_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/orders',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/activities/orders', 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/activities/orders");
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/activities/orders", data)
    req.Header = headers

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

POST /api/v1/activities/orders

Creates an Order

Body parameter

{
  "customer_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	Order	false	Order attributes

Example responses

201 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	Order
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of Orders with a specific Company ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/orders/by_company/{company_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/orders/by_company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/orders/by_company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/orders/by_company/{company_id}',
{
  method: 'GET',

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

<?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/activities/orders/by_company/{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/activities/orders/by_company/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/activities/orders/by_company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/activities/orders/by_company/{company_id}

Renders a list of Orders with a specific Company ID

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company ID
customer_ids	query	array[string]	false	List of customer ids
disabled	query	boolean	false	Return even if disabled

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	Orders
401	Unauthorized	Unauthorized	Unauthorized

Deletes an Order

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/activities/orders/{order_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/activities/orders/{order_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/activities/orders/{order_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/orders/{order_id}',
{
  method: 'DELETE',

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

<?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/activities/orders/{order_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/activities/orders/{order_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/activities/orders/{order_id}", data)
    req.Header = headers

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

DELETE /api/v1/activities/orders/{order_id}

Deletes an Order

Parameters

Name	In	Type	Required	Description
order_id	path	string	true	Order ID

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	Order
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Get Order by ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/activities/orders/{order_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/activities/orders/{order_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/activities/orders/{order_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/orders/{order_id}',
{
  method: 'GET',

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

<?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/activities/orders/{order_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/activities/orders/{order_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/activities/orders/{order_id}", data)
    req.Header = headers

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

GET /api/v1/activities/orders/{order_id}

Get Order by ID

Parameters

Name	In	Type	Required	Description
order_id	path	string	true	Order ID
disabled	query	boolean	false	Return even if disabled

Example responses

200 Response

{
  "customer_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Order
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Updates an Order

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/activities/orders/{order_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/activities/orders/{order_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/activities/orders/{order_id}', headers = headers)

print(r.json())

const inputBody = '{
  "customer_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/activities/orders/{order_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/activities/orders/{order_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/activities/orders/{order_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/activities/orders/{order_id}", data)
    req.Header = headers

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

PUT /api/v1/activities/orders/{order_id}

Updates an Order

Body parameter

{
  "customer_id": "string",
  "disabled": true,
  "name": "string",
  "ref_code": "string"
}

Parameters

Name	In	Type	Required	Description
order_id	path	string	true	Order ID
body	body	Order	false	Order attributes

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	Order
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Approval

Get default approval chain

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/approval_chain \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/approval_chain HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/approval_chain', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/approval_chain',
{
  method: 'GET',

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

<?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}/approval_chain', 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}/approval_chain");
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}/approval_chain", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/approval_chain

Get default approval chain

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id

Example responses

200 Response

{
  "approval_type": "contract",
  "data": {
    "contract_id": "68ddc93f-c264-4eb4-827e-aa5c1aac1608"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ApprovalChain
401	Unauthorized	Unauthorized	Unauthorized

Update default approval chain

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/{company_id}/approval_chain \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/{company_id}/approval_chain HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/companies/{company_id}/approval_chain', headers = headers)

print(r.json())

const inputBody = '{
  "approval_type": "contract",
  "data": {
    "contract_id": "68ddc93f-c264-4eb4-827e-aa5c1aac1608"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/approval_chain',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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}/approval_chain', 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}/approval_chain");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/companies/{company_id}/approval_chain", data)
    req.Header = headers

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

PUT /api/v1/companies/{company_id}/approval_chain

Update default approval chain

Body parameter

{
  "approval_type": "contract",
  "data": {
    "contract_id": "68ddc93f-c264-4eb4-827e-aa5c1aac1608"
  }
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
body	body	ApprovalChain	false	default approval chain configuration

Example responses

401 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	None
401	Unauthorized	Unauthorized	Unauthorized

Get default approval chains configuration

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/approval_chains_by_feature \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/approval_chains_by_feature HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/approval_chains_by_feature', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/approval_chains_by_feature',
{
  method: 'GET',

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

<?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}/approval_chains_by_feature', 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}/approval_chains_by_feature");
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}/approval_chains_by_feature", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/approval_chains_by_feature

Get default approval chains configuration

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id

Example responses

200 Response

{
  "expense_reports": {
    "approval_type": "contract",
    "data": {
      "contract_id": "2a6c8fc6-e1a9-4b03-88af-ffc80c36d4a7"
    }
  },
  "presences": {
    "approval_type": "self_appproval",
    "data": {}
  },
  "stampings": {
    "approval_type": "main_team_leader",
    "data": {}
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ApprovalChainsByFeature
401	Unauthorized	Unauthorized	Unauthorized

Update contract approval chains configuration

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature', headers = headers)

print(r.json())

const inputBody = '{
  "expense_reports": {
    "approval_type": "contract",
    "data": {
      "contract_id": "2a6c8fc6-e1a9-4b03-88af-ffc80c36d4a7"
    }
  },
  "presences": {
    "approval_type": "self_appproval",
    "data": {}
  },
  "stampings": {
    "approval_type": "main_team_leader",
    "data": {}
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/contracts/{contract_id}/approval_chains_by_feature', 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/contracts/{contract_id}/approval_chains_by_feature");
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/contracts/{contract_id}/approval_chains_by_feature", data)
    req.Header = headers

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

PUT /api/v1/contracts/{contract_id}/approval_chains_by_feature

Update contract approval chains configuration

Body parameter

{
  "expense_reports": {
    "approval_type": "contract",
    "data": {
      "contract_id": "2a6c8fc6-e1a9-4b03-88af-ffc80c36d4a7"
    }
  },
  "presences": {
    "approval_type": "self_appproval",
    "data": {}
  },
  "stampings": {
    "approval_type": "main_team_leader",
    "data": {}
  }
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
body	body	ApprovalChainsByFeature	false	contract approval chains configuration

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Get contract approval chain

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain',
{
  method: 'GET',

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

<?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/contracts/{contract_id}/approval_chain', 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/contracts/{contract_id}/approval_chain");
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/contracts/{contract_id}/approval_chain", data)
    req.Header = headers

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

GET /api/v1/contracts/{contract_id}/approval_chain

Get contract approval chain

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id

Example responses

200 Response

{
  "approval_type": "contract",
  "data": {
    "contract_id": "68ddc93f-c264-4eb4-827e-aa5c1aac1608"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ApprovalChain
401	Unauthorized	Unauthorized	Unauthorized

Update contract approval chain

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain', headers = headers)

print(r.json())

const inputBody = '{
  "approval_type": "contract",
  "data": {
    "contract_id": "68ddc93f-c264-4eb4-827e-aa5c1aac1608"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/contracts/{contract_id}/approval_chain', 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/contracts/{contract_id}/approval_chain");
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/contracts/{contract_id}/approval_chain", data)
    req.Header = headers

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

PUT /api/v1/contracts/{contract_id}/approval_chain

Update contract approval chain

Body parameter

{
  "approval_type": "contract",
  "data": {
    "contract_id": "68ddc93f-c264-4eb4-827e-aa5c1aac1608"
  }
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
body	body	ApprovalChain	false	contract approval chain configuration

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Get contract approval chains configuration

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature',
{
  method: 'GET',

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

<?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/contracts/{contract_id}/approval_chains_by_feature', 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/contracts/{contract_id}/approval_chains_by_feature");
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/contracts/{contract_id}/approval_chains_by_feature", data)
    req.Header = headers

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

GET /api/v1/contracts/{contract_id}/approval_chains_by_feature

Get contract approval chains configuration

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id

Example responses

200 Response

{
  "expense_reports": {
    "approval_type": "contract",
    "data": {
      "contract_id": "2a6c8fc6-e1a9-4b03-88af-ffc80c36d4a7"
    }
  },
  "presences": {
    "approval_type": "self_appproval",
    "data": {}
  },
  "stampings": {
    "approval_type": "main_team_leader",
    "data": {}
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ApprovalChainsByFeature
401	Unauthorized	Unauthorized	Unauthorized

Get an approval chain template

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}',
{
  method: 'GET',

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

<?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}/approval_chain_templates/{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}/approval_chain_templates/{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}/approval_chain_templates/{id}", data)
    req.Header = headers

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

GET /api/v1/requests/{company_id}/approval_chain_templates/{id}

Get an approval chain template

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company ID
id	path	string	true	Approval chain template ID

Example responses

200 Response

{
  "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
  "default": false,
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "mode": "and",
  "name": "Test",
  "steps": []
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ApprovalChainTemplate
401	Unauthorized	Unauthorized	Unauthorized

Create an approval chain template

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
  "default": false,
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "mode": "and",
  "name": "Test",
  "steps": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/{company_id}/approval_chain_templates', 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}/approval_chain_templates");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates", data)
    req.Header = headers

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

POST /api/v1/requests/{company_id}/approval_chain_templates

Create an approval chain template

Body parameter

{
  "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
  "default": false,
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "mode": "and",
  "name": "Test",
  "steps": []
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company ID
body	body	ApprovalChainTemplate	false	Request body

Example responses

201 Response

{
  "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
  "default": false,
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "mode": "and",
  "name": "Test",
  "steps": []
}

Responses

Status	Meaning	Description	Schema
201	Created	Created	ApprovalChainTemplate
401	Unauthorized	Unauthorized	Unauthorized

Delete an approval chain template

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}',
{
  method: 'DELETE',

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

<?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/requests/{company_id}/approval_chain_templates/{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}/approval_chain_templates/{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/requests/{company_id}/approval_chain_templates/{id}", data)
    req.Header = headers

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

DELETE /api/v1/requests/{company_id}/approval_chain_templates/{id}

Delete an approval chain template

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company ID
id	path	string	true	Approval chain template ID

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ApprovalChainTemplate
401	Unauthorized	Unauthorized	Unauthorized

Update an approval chain template

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
  "default": false,
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "mode": "and",
  "name": "Test",
  "steps": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/requests/{company_id}/approval_chain_templates/{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}/approval_chain_templates/{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{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}", data)
    req.Header = headers

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

PUT /api/v1/requests/{company_id}/approval_chain_templates/{id}

Update an approval chain template

Body parameter

{
  "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
  "default": false,
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "mode": "and",
  "name": "Test",
  "steps": []
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company ID
id	path	string	true	Approval chain template ID
body	body	ApprovalChainTemplate	false	Request body

Example responses

200 Response

{
  "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
  "default": false,
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
  "mode": "and",
  "name": "Test",
  "steps": []
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ApprovalChainTemplate
401	Unauthorized	Unauthorized	Unauthorized

Calendar

Renders a list of working days for a given company in a range of days

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/company/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/company/{company_id}',
{
  method: 'GET',

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

<?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/calendar/company/{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/calendar/company/{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/calendar/company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/calendar/company/{company_id}

Renders a list of working days for a given company in a range of days...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
start_date	query	string	false	Start date
end_date	query	string	false	End date
team_ids	query	array[string]	false	Team Ids
subsidiary_ids	query	array[string]	false	Subsidiary Ids

Example responses

200 Response

[
  {
    "actual_calendar": [
      {
        "additive": false,
        "duration_rounding": 1,
        "end": "08:59:59",
        "end_datetime": "2022-02-01T08:59:59+01:00",
        "fixed": false,
        "fixed_end": "09:00:00",
        "mismatched": false,
        "overnight": false,
        "presence": false,
        "start": "00:00:00",
        "start_datetime": "2022-02-01T00:00:00+01:00",
        "workplace": {}
      },
      {
        "additive": false,
        "duration": 240,
        "duration_rounding": 1,
        "end": "12:59:59",
        "end_datetime": "2022-02-01T12:59:59+01:00",
        "fixed": false,
        "fixed_end": "13:00:00",
        "mismatch_reason": "time_mismatch",
        "mismatched": true,
        "original_id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "overnight": false,
        "presence": false,
        "start": "09:00:00",
        "start_datetime": "2022-02-01T09:00:00+01:00",
        "subsidiary_id": "9b945939-8452-43f7-bead-408798febf58",
        "type_label": "mismatched_absence",
        "type_name": "COMMON.MISMATCHED_ABSENCE",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "additive": false,
        "duration": 60,
        "duration_rounding": 1,
        "end": "13:59:59",
        "end_datetime": "2022-02-01T13:59:59+01:00",
        "fixed": false,
        "fixed_end": "14:00:00",
        "mismatched": false,
        "overnight": false,
        "presence": false,
        "start": "13:00:00",
        "start_datetime": "2022-02-01T13:00:00+01:00",
        "subsidiary_id": "9b945939-8452-43f7-bead-408798febf58",
        "type_label": "break",
        "workplace": {}
      },
      {
        "additive": false,
        "duration": 240,
        "duration_rounding": 1,
        "end": "17:59:59",
        "end_datetime": "2022-02-01T17:59:59+01:00",
        "fixed": false,
        "fixed_end": "18:00:00",
        "mismatch_reason": "time_mismatch",
        "mismatched": true,
        "original_id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "overnight": false,
        "presence": false,
        "start": "14:00:00",
        "start_datetime": "2022-02-01T14:00:00+01:00",
        "subsidiary_id": "9b945939-8452-43f7-bead-408798febf58",
        "type_label": "mismatched_absence",
        "type_name": "COMMON.MISMATCHED_ABSENCE",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "additive": false,
        "duration_rounding": 1,
        "end": "23:59:59",
        "end_datetime": "2022-02-01T23:59:59+01:00",
        "fixed": false,
        "fixed_end": "00:00:00",
        "mismatched": false,
        "overnight": false,
        "presence": false,
        "start": "18:00:00",
        "start_datetime": "2022-02-01T18:00:00+01:00",
        "workplace": {}
      }
    ],
    "actual_extra_time_minutes": 4,
    "actual_regular_work_minutes": 3,
    "company_id": "354621d2-b1f3-4b20-b164-8165a67d3b8d",
    "contract_clocking_duty": "never",
    "contract_id": "64633a6f-1138-4f88-88f0-9426641fdc35",
    "day": "2024-07-15",
    "expected_extra_time_minutes": 2,
    "expected_regular_work_minutes": 0,
    "flexible_actual_calendar": [
      {
        "additive": false,
        "duration": 480,
        "duration_rounding": 1,
        "fixed": false,
        "mismatch_reason": "time_mismatch",
        "mismatched": true,
        "presence": false,
        "type_label": "mismatched_absence",
        "type_name": "COMMON.MISMATCHED_ABSENCE",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      }
    ],
    "flexible_schedule": [
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 480,
        "duration_rounding": 1,
        "flexible": false,
        "id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "last_update": "2022-02-01T05:37:18+00:00",
        "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "presence": true,
        "requested_at": "2022-02-01T05:37:15+00:00",
        "requested_by": "77589503-3daf-4359-b52b-3e295920b001",
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      }
    ],
    "is_company_holiday": false,
    "is_flexible": true,
    "is_subsidiary_holiday": false,
    "is_worker_holiday": false,
    "mismatched_absence_minutes": 4,
    "mismatched_work_minutes": 4,
    "mismatches": [
      {
        "duration": 240,
        "end": "12:59:59",
        "end_datetime": "2022-02-01T12:59:59+01:00",
        "fixed_end": "13:00:00",
        "is_on_interval": true,
        "mismatch_reason": "time_mismatch",
        "overnight": false,
        "start": "09:00:00",
        "start_datetime": "2022-02-01T09:00:00+01:00",
        "type": "mismatched_absence"
      },
      {
        "duration": 240,
        "end": "17:59:59",
        "end_datetime": "2022-02-01T17:59:59+01:00",
        "fixed_end": "18:00:00",
        "is_on_interval": true,
        "mismatch_reason": "time_mismatch",
        "overnight": false,
        "start": "14:00:00",
        "start_datetime": "2022-02-01T14:00:00+01:00",
        "type": "mismatched_absence"
      }
    ],
    "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
    "presence_entries": [
      {
        "complete": false,
        "datetime": "2024-07-15T13:26:47.387512Z",
        "direction": "IN",
        "id": "5186d5f4-1fab-46ac-88a5-22243f60a9a0",
        "last_update": "2024-07-15T13:26:47.387505Z",
        "start": "09:00:00",
        "start_datetime": "2024-07-15T13:26:47.387514Z",
        "status": "recorded",
        "subsidiary_id": "97a5ae37-52dd-4443-96ca-1647f69b61c3",
        "time": "09:00:00",
        "timezone": "Europe/Rome"
      },
      {
        "complete": false,
        "datetime": "2024-07-15T13:26:47.387524Z",
        "direction": "OUT",
        "end": "13:00:00",
        "end_datetime": "2024-07-15T13:26:47.387526Z",
        "id": "0eef68dd-e10a-41da-a68f-0738a11b8814",
        "last_update": "2024-07-15T13:26:47.387523Z",
        "status": "recorded",
        "subsidiary_id": "b7be5e06-73c1-47bc-a0f9-85d16ce4cf26",
        "time": "13:00:00",
        "timezone": "Europe/Rome"
      }
    ],
    "schedule": [
      {
        "duration_rounding": 1,
        "end": "08:59:59",
        "fixed_end": "09:00:00",
        "flexible": false,
        "presence": false,
        "start": "00:00:00",
        "workplace": {}
      },
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 240,
        "duration_rounding": 1,
        "end": "12:59:59",
        "fixed_end": "13:00:00",
        "flexible": false,
        "id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "last_update": "2022-02-01T05:37:18+00:00",
        "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "presence": true,
        "requested_at": "2022-02-01T05:37:15+00:00",
        "requested_by": "77589503-3daf-4359-b52b-3e295920b001",
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "start": "09:00:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "duration_rounding": 1,
        "end": "13:59:59",
        "fixed_end": "14:00:00",
        "flexible": false,
        "presence": false,
        "start": "13:00:00",
        "workplace": {}
      },
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 240,
        "duration_rounding": 1,
        "end": "17:59:59",
        "fixed_end": "18:00:00",
        "flexible": false,
        "id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "last_update": "2022-02-01T05:37:18+00:00",
        "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "presence": true,
        "requested_at": "2022-02-01T05:37:15+00:00",
        "requested_by": "77589503-3daf-4359-b52b-3e295920b001",
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "start": "14:00:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "duration_rounding": 1,
        "end": "23:59:59",
        "fixed_end": "00:00:00",
        "flexible": false,
        "presence": false,
        "start": "18:00:00",
        "workplace": {}
      }
    ],
    "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
    "shift_override_id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
    "shift_override_type": "daily",
    "squaring_enabled": true,
    "subsidiary_id": "2df45501-d3c7-43e3-a423-e5033d5b1fa7",
    "subsidiary_ids": [
      "aff8aa52-7e7f-4a79-9b68-c920987945da"
    ],
    "summary": {
      "absences": {
        "details": [],
        "duration": 0
      },
      "day": "2022-02-01",
      "extraordinary": {
        "details": [],
        "duration": 0
      },
      "is_company_holiday": false,
      "is_day_off": false,
      "is_subsidiary_holiday": false,
      "is_worker_holiday": false,
      "mismatched": false,
      "mismatches": {
        "details": [],
        "duration": 0
      },
      "presences": {
        "details": [
          {
            "duration": 480,
            "presence": true,
            "type_label": "work",
            "type_name": "work"
          }
        ],
        "duration": 480
      }
    },
    "team_ids": [
      "3fe6706e-ac1c-4328-9809-8507f9e41990"
    ],
    "timezone": "Etc/UTC",
    "user_id": "85ed9695-b92c-4fc6-a597-e7d702ddf70e"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	ActualCalendarEntries

Summary of actual working days with the entry list

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/company/{company_id}/actual_calendar_with_summary \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/company/{company_id}/actual_calendar_with_summary HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/company/{company_id}/actual_calendar_with_summary', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/company/{company_id}/actual_calendar_with_summary',
{
  method: 'GET',

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

<?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/calendar/company/{company_id}/actual_calendar_with_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/calendar/company/{company_id}/actual_calendar_with_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/calendar/company/{company_id}/actual_calendar_with_summary", data)
    req.Header = headers

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

GET /api/v1/calendar/company/{company_id}/actual_calendar_with_summary

Renders a summary of actual working days with the entry list by company in a range of days

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
contract_id	query	string	false	Contract Id
start_date	query	string	false	Start date
end_date	query	string	false	End date
team_ids	query	array[string]	false	Team Ids
subsidiary_ids	query	array[string]	false	Subsidiary Ids

Example responses

200 Response

{
  "actual_extra_time_minutes": 0,
  "actual_regular_work_minutes": 0,
  "details": [
    {
      "actual_calendar": [
        {
          "additive": false,
          "duration_rounding": 1,
          "end": "08:59:59",
          "end_datetime": "2022-02-01T08:59:59+01:00",
          "fixed": false,
          "fixed_end": "09:00:00",
          "mismatched": false,
          "overnight": false,
          "presence": false,
          "start": "00:00:00",
          "start_datetime": "2022-02-01T00:00:00+01:00",
          "workplace": {}
        },
        {
          "additive": false,
          "duration": 240,
          "duration_rounding": 1,
          "end": "12:59:59",
          "end_datetime": "2022-02-01T12:59:59+01:00",
          "fixed": false,
          "fixed_end": "13:00:00",
          "mismatch_reason": "time_mismatch",
          "mismatched": true,
          "original_id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
          "overnight": false,
          "presence": false,
          "start": "09:00:00",
          "start_datetime": "2022-02-01T09:00:00+01:00",
          "subsidiary_id": "9b945939-8452-43f7-bead-408798febf58",
          "type_label": "mismatched_absence",
          "type_name": "COMMON.MISMATCHED_ABSENCE",
          "workplace": {
            "id": "9b945939-8452-43f7-bead-408798febf58",
            "label": "subsidiary",
            "type": "subsidiary"
          }
        },
        {
          "additive": false,
          "duration": 60,
          "duration_rounding": 1,
          "end": "13:59:59",
          "end_datetime": "2022-02-01T13:59:59+01:00",
          "fixed": false,
          "fixed_end": "14:00:00",
          "mismatched": false,
          "overnight": false,
          "presence": false,
          "start": "13:00:00",
          "start_datetime": "2022-02-01T13:00:00+01:00",
          "subsidiary_id": "9b945939-8452-43f7-bead-408798febf58",
          "type_label": "break",
          "workplace": {}
        },
        {
          "additive": false,
          "duration": 240,
          "duration_rounding": 1,
          "end": "17:59:59",
          "end_datetime": "2022-02-01T17:59:59+01:00",
          "fixed": false,
          "fixed_end": "18:00:00",
          "mismatch_reason": "time_mismatch",
          "mismatched": true,
          "original_id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
          "overnight": false,
          "presence": false,
          "start": "14:00:00",
          "start_datetime": "2022-02-01T14:00:00+01:00",
          "subsidiary_id": "9b945939-8452-43f7-bead-408798febf58",
          "type_label": "mismatched_absence",
          "type_name": "COMMON.MISMATCHED_ABSENCE",
          "workplace": {
            "id": "9b945939-8452-43f7-bead-408798febf58",
            "label": "subsidiary",
            "type": "subsidiary"
          }
        },
        {
          "additive": false,
          "duration_rounding": 1,
          "end": "23:59:59",
          "end_datetime": "2022-02-01T23:59:59+01:00",
          "fixed": false,
          "fixed_end": "00:00:00",
          "mismatched": false,
          "overnight": false,
          "presence": false,
          "start": "18:00:00",
          "start_datetime": "2022-02-01T18:00:00+01:00",
          "workplace": {}
        }
      ],
      "actual_extra_time_minutes": 4,
      "actual_regular_work_minutes": 3,
      "company_id": "354621d2-b1f3-4b20-b164-8165a67d3b8d",
      "contract_clocking_duty": "never",
      "contract_id": "64633a6f-1138-4f88-88f0-9426641fdc35",
      "day": "2024-07-15",
      "expected_extra_time_minutes": 2,
      "expected_regular_work_minutes": 0,
      "flexible_actual_calendar": [
        {
          "additive": false,
          "duration": 480,
          "duration_rounding": 1,
          "fixed": false,
          "mismatch_reason": "time_mismatch",
          "mismatched": true,
          "presence": false,
          "type_label": "mismatched_absence",
          "type_name": "COMMON.MISMATCHED_ABSENCE",
          "workplace": {
            "id": "9b945939-8452-43f7-bead-408798febf58",
            "label": "subsidiary",
            "type": "subsidiary"
          }
        }
      ],
      "flexible_schedule": [
        {
          "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
          "duration": 480,
          "duration_rounding": 1,
          "flexible": false,
          "id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
          "last_update": "2022-02-01T05:37:18+00:00",
          "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
          "presence": true,
          "requested_at": "2022-02-01T05:37:15+00:00",
          "requested_by": "77589503-3daf-4359-b52b-3e295920b001",
          "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
          "type_label": "work",
          "type_name": "work",
          "workplace": {
            "id": "9b945939-8452-43f7-bead-408798febf58",
            "label": "subsidiary",
            "type": "subsidiary"
          }
        }
      ],
      "is_company_holiday": false,
      "is_flexible": true,
      "is_subsidiary_holiday": false,
      "is_worker_holiday": false,
      "mismatched_absence_minutes": 4,
      "mismatched_work_minutes": 4,
      "mismatches": [
        {
          "duration": 240,
          "end": "12:59:59",
          "end_datetime": "2022-02-01T12:59:59+01:00",
          "fixed_end": "13:00:00",
          "is_on_interval": true,
          "mismatch_reason": "time_mismatch",
          "overnight": false,
          "start": "09:00:00",
          "start_datetime": "2022-02-01T09:00:00+01:00",
          "type": "mismatched_absence"
        },
        {
          "duration": 240,
          "end": "17:59:59",
          "end_datetime": "2022-02-01T17:59:59+01:00",
          "fixed_end": "18:00:00",
          "is_on_interval": true,
          "mismatch_reason": "time_mismatch",
          "overnight": false,
          "start": "14:00:00",
          "start_datetime": "2022-02-01T14:00:00+01:00",
          "type": "mismatched_absence"
        }
      ],
      "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
      "presence_entries": [
        {
          "complete": false,
          "datetime": "2024-07-15T13:26:47.387512Z",
          "direction": "IN",
          "id": "5186d5f4-1fab-46ac-88a5-22243f60a9a0",
          "last_update": "2024-07-15T13:26:47.387505Z",
          "start": "09:00:00",
          "start_datetime": "2024-07-15T13:26:47.387514Z",
          "status": "recorded",
          "subsidiary_id": "97a5ae37-52dd-4443-96ca-1647f69b61c3",
          "time": "09:00:00",
          "timezone": "Europe/Rome"
        },
        {
          "complete": false,
          "datetime": "2024-07-15T13:26:47.387524Z",
          "direction": "OUT",
          "end": "13:00:00",
          "end_datetime": "2024-07-15T13:26:47.387526Z",
          "id": "0eef68dd-e10a-41da-a68f-0738a11b8814",
          "last_update": "2024-07-15T13:26:47.387523Z",
          "status": "recorded",
          "subsidiary_id": "b7be5e06-73c1-47bc-a0f9-85d16ce4cf26",
          "time": "13:00:00",
          "timezone": "Europe/Rome"
        }
      ],
      "schedule": [
        {
          "duration_rounding": 1,
          "end": "08:59:59",
          "fixed_end": "09:00:00",
          "flexible": false,
          "presence": false,
          "start": "00:00:00",
          "workplace": {}
        },
        {
          "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
          "duration": 240,
          "duration_rounding": 1,
          "end": "12:59:59",
          "fixed_end": "13:00:00",
          "flexible": false,
          "id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
          "last_update": "2022-02-01T05:37:18+00:00",
          "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
          "presence": true,
          "requested_at": "2022-02-01T05:37:15+00:00",
          "requested_by": "77589503-3daf-4359-b52b-3e295920b001",
          "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
          "start": "09:00:00",
          "type_label": "work",
          "type_name": "work",
          "workplace": {
            "id": "9b945939-8452-43f7-bead-408798febf58",
            "label": "subsidiary",
            "type": "subsidiary"
          }
        },
        {
          "duration_rounding": 1,
          "end": "13:59:59",
          "fixed_end": "14:00:00",
          "flexible": false,
          "presence": false,
          "start": "13:00:00",
          "workplace": {}
        },
        {
          "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
          "duration": 240,
          "duration_rounding": 1,
          "end": "17:59:59",
          "fixed_end": "18:00:00",
          "flexible": false,
          "id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
          "last_update": "2022-02-01T05:37:18+00:00",
          "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
          "presence": true,
          "requested_at": "2022-02-01T05:37:15+00:00",
          "requested_by": "77589503-3daf-4359-b52b-3e295920b001",
          "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
          "start": "14:00:00",
          "type_label": "work",
          "type_name": "work",
          "workplace": {
            "id": "9b945939-8452-43f7-bead-408798febf58",
            "label": "subsidiary",
            "type": "subsidiary"
          }
        },
        {
          "duration_rounding": 1,
          "end": "23:59:59",
          "fixed_end": "00:00:00",
          "flexible": false,
          "presence": false,
          "start": "18:00:00",
          "workplace": {}
        }
      ],
      "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
      "shift_override_id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
      "shift_override_type": "daily",
      "squaring_enabled": true,
      "subsidiary_id": "2df45501-d3c7-43e3-a423-e5033d5b1fa7",
      "subsidiary_ids": [
        "aff8aa52-7e7f-4a79-9b68-c920987945da"
      ],
      "summary": {
        "absences": {
          "details": [],
          "duration": 0
        },
        "day": "2022-02-01",
        "extraordinary": {
          "details": [],
          "duration": 0
        },
        "is_company_holiday": false,
        "is_day_off": false,
        "is_subsidiary_holiday": false,
        "is_worker_holiday": false,
        "mismatched": false,
        "mismatches": {
          "details": [],
          "duration": 0
        },
        "presences": {
          "details": [
            {
              "duration": 480,
              "presence": true,
              "type_label": "work",
              "type_name": "work"
            }
          ],
          "duration": 480
        }
      },
      "team_ids": [
        "3fe6706e-ac1c-4328-9809-8507f9e41990"
      ],
      "timezone": "Etc/UTC",
      "user_id": "85ed9695-b92c-4fc6-a597-e7d702ddf70e"
    }
  ],
  "expected_extra_time_minutes": 0,
  "expected_regular_work_minutes": 0,
  "mismatched_absence_minutes": 0,
  "mismatched_work_minutes": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ActualCalendarSummary

Renders a list of working days for a given company in a range of days lightweight

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/company/{company_id}/light \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/company/{company_id}/light HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/company/{company_id}/light', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/company/{company_id}/light',
{
  method: 'GET',

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

<?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/calendar/company/{company_id}/light', 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/calendar/company/{company_id}/light");
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/calendar/company/{company_id}/light", data)
    req.Header = headers

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

GET /api/v1/calendar/company/{company_id}/light

Renders a list of working days for a given company in a range of days lightweight version optimized for mobile devices

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
start_date	query	string	false	Start date
end_date	query	string	false	End date
team_ids	query	array[string]	false	Team Ids
subsidiary_ids	query	array[string]	false	Subsidiary Ids

Example responses

200 Response

[
  {
    "actual_calendar": [
      {
        "additive": false,
        "duration": 480,
        "duration_rounding": 1,
        "fixed": false,
        "mismatch_reason": "time_mismatch",
        "mismatched": true,
        "presence": false,
        "type_label": "mismatched_absence",
        "type_name": "COMMON.MISMATCHED_ABSENCE",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      }
    ],
    "company_id": "e7ce8140-8dce-4dd2-bfd4-25ee09b9fee5",
    "contract_clocking_duty": "never",
    "contract_id": "b031b69a-349b-4a69-b73b-f2a60ef274e2",
    "day": "2024-07-15",
    "is_company_holiday": false,
    "is_flexible": true,
    "is_subsidiary_holiday": false,
    "is_worker_holiday": false,
    "mismatches": [
      {
        "duration": 240,
        "end": "12:59:59",
        "end_datetime": "2022-02-01T12:59:59+01:00",
        "fixed_end": "13:00:00",
        "is_on_interval": true,
        "mismatch_reason": "time_mismatch",
        "overnight": false,
        "start": "09:00:00",
        "start_datetime": "2022-02-01T09:00:00+01:00",
        "type": "mismatched_absence"
      },
      {
        "duration": 240,
        "end": "17:59:59",
        "end_datetime": "2022-02-01T17:59:59+01:00",
        "fixed_end": "18:00:00",
        "is_on_interval": true,
        "mismatch_reason": "time_mismatch",
        "overnight": false,
        "start": "14:00:00",
        "start_datetime": "2022-02-01T14:00:00+01:00",
        "type": "mismatched_absence"
      }
    ],
    "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
    "schedule": [
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 480,
        "duration_rounding": 1,
        "flexible": false,
        "id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "last_update": "2022-02-01T05:37:18+00:00",
        "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "presence": true,
        "requested_at": "2022-02-01T05:37:15+00:00",
        "requested_by": "77589503-3daf-4359-b52b-3e295920b001",
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      }
    ],
    "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
    "shift_override_id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
    "shift_override_type": "daily",
    "squaring_enabled": true,
    "subsidiary_id": "ec275740-9614-49c6-bceb-6b1af252087c",
    "subsidiary_ids": [
      "bac2764f-0d0d-422a-b087-52e5cee88f3b"
    ],
    "team_ids": [
      "71a45d43-a028-4350-a351-11a49eb76e7e"
    ],
    "timezone": "Etc/UTC",
    "user_id": "13caf1aa-f1e0-4a55-8f74-91b12323ad61"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	LightActualCalendarEntries

Renders calendar summary by contract for a given company in a range of days

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_contract \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_contract HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_contract', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_contract',
{
  method: 'GET',

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

<?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/calendar/company/{company_id}/summary_by_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/calendar/company/{company_id}/summary_by_contract");
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/calendar/company/{company_id}/summary_by_contract", data)
    req.Header = headers

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

GET /api/v1/calendar/company/{company_id}/summary_by_contract

Renders calendar summary by contract for a given company in a range of days

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
start_date	query	string	false	Start date
end_date	query	string	false	End date
team_ids	query	array[string]	false	Team Ids
subsidiary_ids	query	array[string]	false	Subsidiary Ids
contract_id	query	string	false	Contract ID

Example responses

200 Response

null

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

Renders calendar summary by day for a given company in a range of days

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_day \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_day HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_day', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_day',
{
  method: 'GET',

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

<?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/calendar/company/{company_id}/summary_by_day', 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/calendar/company/{company_id}/summary_by_day");
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/calendar/company/{company_id}/summary_by_day", data)
    req.Header = headers

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

GET /api/v1/calendar/company/{company_id}/summary_by_day

Renders calendar summary by day for a given company in a range of days

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
start_date	query	string	false	Start date
end_date	query	string	false	End date
team_ids	query	array[string]	false	Team Ids
subsidiary_ids	query	array[string]	false	Subsidiary Ids
contract_id	query	string	false	Contract ID

Example responses

200 Response

[
  {
    "absences": {
      "details": [
        {
          "additive": false,
          "duration": 50,
          "presence": false,
          "type_label": "holiday",
          "type_name": "Holday"
        },
        {
          "additive": false,
          "duration": 50,
          "presence": false,
          "type_label": "permit",
          "type_name": "Permit"
        }
      ],
      "duration": 200
    },
    "day": "2020-05-05",
    "extraordinary": {
      "details": [
        {
          "additive": true,
          "duration": 60,
          "presence": true,
          "type_label": "extra",
          "type_name": "extra"
        }
      ],
      "duration": 60
    },
    "is_company_holiday": false,
    "is_day_off": false,
    "is_subsidiary_holiday": false,
    "is_worker_holiday": false,
    "mismatched": true,
    "mismatches": {
      "details": [
        {
          "additive": false,
          "duration": 60,
          "presence": false,
          "type_label": "mismatched_absence",
          "type_name": "COMMON.MISMATCED_ABSENCE"
        }
      ],
      "duration": 60
    },
    "presences": {
      "details": [
        {
          "additive": false,
          "duration": 480,
          "presence": true,
          "type_label": "work",
          "type_name": "work"
        }
      ],
      "duration": 480
    }
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	DayCalendarSummaries

Creates a company holiday

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/calendar/company_holidays \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/calendar/company_holidays HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/calendar/company_holidays', headers = headers)

print(r.json())

const inputBody = '{
  "day": "string",
  "id": "string",
  "name": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "to_day": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/company_holidays',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/calendar/company_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/calendar/company_holidays");
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/calendar/company_holidays", data)
    req.Header = headers

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

POST /api/v1/calendar/company_holidays

Creates a company holiday...

Body parameter

{
  "day": "string",
  "id": "string",
  "name": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "to_day": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	CompanyHoliday	false	holiday attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Deletes a company holiday

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/calendar/company_holidays/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/calendar/company_holidays/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/calendar/company_holidays/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/company_holidays/{id}',
{
  method: 'DELETE',

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

<?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/calendar/company_holidays/{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/calendar/company_holidays/{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/calendar/company_holidays/{id}", data)
    req.Header = headers

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

DELETE /api/v1/calendar/company_holidays/{id}

Deletes a company holiday...

Parameters

Name	In	Type	Required	Description
id	path	string	true	company id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Updates a company holiday

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/calendar/company_holidays/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/calendar/company_holidays/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/calendar/company_holidays/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "day": "string",
  "id": "string",
  "name": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "to_day": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/company_holidays/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/calendar/company_holidays/{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/calendar/company_holidays/{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/calendar/company_holidays/{id}", data)
    req.Header = headers

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

PUT /api/v1/calendar/company_holidays/{id}

Updates a company holiday...

Body parameter

{
  "day": "string",
  "id": "string",
  "name": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "to_day": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	company id
body	body	CompanyHoliday	false	holiday attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Fix mismatches on calendar day

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/calendar/contracts/{contract_id}/fix_mismatches \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/calendar/contracts/{contract_id}/fix_mismatches HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/calendar/contracts/{contract_id}/fix_mismatches', headers = headers)

print(r.json())

const inputBody = '{
  "contract_id": "a3c76281-6010-448f-9fff-9f47fae78f7a",
  "day": {
    "calendar": "Elixir.Calendar.ISO",
    "day": 15,
    "month": 7,
    "year": 2024
  },
  "fix": {
    "duration": 10,
    "fixing_method": "ignore_mismatch",
    "is_on_interval": false
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/contracts/{contract_id}/fix_mismatches',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/calendar/contracts/{contract_id}/fix_mismatches', 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/calendar/contracts/{contract_id}/fix_mismatches");
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/calendar/contracts/{contract_id}/fix_mismatches", data)
    req.Header = headers

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

PUT /api/v1/calendar/contracts/{contract_id}/fix_mismatches

Fix mismatches on calendar day

Body parameter

{
  "contract_id": "a3c76281-6010-448f-9fff-9f47fae78f7a",
  "day": {
    "calendar": "Elixir.Calendar.ISO",
    "day": 15,
    "month": 7,
    "year": 2024
  },
  "fix": {
    "duration": 10,
    "fixing_method": "ignore_mismatch",
    "is_on_interval": false
  }
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
body	body	MismatchFixParams	false	mismatch fix params

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	None

Render Contract Presence Status

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/presence_status/company/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/presence_status/company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/presence_status/company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presence_status/company/{company_id}',
{
  method: 'GET',

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

<?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/calendar/presence_status/company/{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/calendar/presence_status/company/{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/calendar/presence_status/company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/calendar/presence_status/company/{company_id}

Render Contract Presence Status for a given company on at datetime

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
contract_id	query	string	false	Contract Id
datetime	query	string	false	Datetime
team_ids	query	array[string]	false	Team Ids
subsidiary_ids	query	array[string]	false	Subsidiary Ids

Example responses

200 Response

{
  "22b8c307-8c8e-4e9d-ad7e-24e6f61c09cb": "present",
  "916cf9f6-42f3-4fee-a570-dc79ed0e41f2": "absent"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	PresenceStatus

Render Contract Presence Status By Subsidiary

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/presence_status/company/{company_id}/subsidiary?date=string \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/presence_status/company/{company_id}/subsidiary?date=string HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/presence_status/company/{company_id}/subsidiary', params={
  'date': 'string'
}, headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presence_status/company/{company_id}/subsidiary?date=string',
{
  method: 'GET',

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

<?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/calendar/presence_status/company/{company_id}/subsidiary', 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/calendar/presence_status/company/{company_id}/subsidiary?date=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/calendar/presence_status/company/{company_id}/subsidiary", data)
    req.Header = headers

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

GET /api/v1/calendar/presence_status/company/{company_id}/subsidiary

Render Contract Presence Status By Subsidiary for a given company and date

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	CompanyId
date	query	string	true	Datetime
subsidiary_ids	query	array[string]	false	SubsidiaryIds
team_ids	query	array[string]	false	TeamIds

Example responses

200 Response

{
  "22b8c307-8c8e-4e9d-ad7e-24e6f61c09cb": "present",
  "916cf9f6-42f3-4fee-a570-dc79ed0e41f2": "absent"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	PresenceStatus

Renders count of absences/presences for a given company on a day

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/presences/company/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/presences/company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/presences/company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presences/company/{company_id}',
{
  method: 'GET',

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

<?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/calendar/presences/company/{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/calendar/presences/company/{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/calendar/presences/company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/calendar/presences/company/{company_id}

Renders count of absences/presences for a given company on a day...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
date	query	string	false	Date
team_ids	query	array[string]	false	Team Ids
subsidiary_ids	query	array[string]	false	Subsidiary Ids
timezone	query	string	false	Client Timezone

Example responses

200 Response

{
  "absences": {
    "contracts": {
      "holiday": [
        "92af235f-2d6b-4c86-9519-eedd5a720f89"
      ]
    },
    "details": {
      "holiday": 1
    },
    "total": 1
  },
  "actual_presences": {
    "contracts": [
      "e43114ae-e6d4-4aaf-ab17-39e06f024dd3"
    ],
    "total": 1
  },
  "presences": {
    "contracts": {
      "work": [
        "d29dfab9-d6e4-4587-a2fc-1efbde8f2f83"
      ]
    },
    "details": {
      "work": 1
    },
    "total": 1
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Analytic

Renders count of absences/presences for a given subsidiary on a day

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/presences/subsidiary/{company_id}/{subsidiary_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/presences/subsidiary/{company_id}/{subsidiary_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/presences/subsidiary/{company_id}/{subsidiary_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presences/subsidiary/{company_id}/{subsidiary_id}',
{
  method: 'GET',

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

<?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/calendar/presences/subsidiary/{company_id}/{subsidiary_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/calendar/presences/subsidiary/{company_id}/{subsidiary_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/calendar/presences/subsidiary/{company_id}/{subsidiary_id}", data)
    req.Header = headers

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

GET /api/v1/calendar/presences/subsidiary/{company_id}/{subsidiary_id}

Renders count of absences/presences for a given subsidiary on a day...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
subsidiary_id	path	string	true	subsidiary id
date	query	string	false	Date

Example responses

200 Response

{
  "absences": {
    "contracts": {
      "holiday": [
        "92af235f-2d6b-4c86-9519-eedd5a720f89"
      ]
    },
    "details": {
      "holiday": 1
    },
    "total": 1
  },
  "actual_presences": {
    "contracts": [
      "e43114ae-e6d4-4aaf-ab17-39e06f024dd3"
    ],
    "total": 1
  },
  "presences": {
    "contracts": {
      "work": [
        "d29dfab9-d6e4-4587-a2fc-1efbde8f2f83"
      ]
    },
    "details": {
      "work": 1
    },
    "total": 1
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Analytic

Renders count of absences/presences for a given team on a day

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/presences/team/{company_id}/{team_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/presences/team/{company_id}/{team_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/presences/team/{company_id}/{team_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presences/team/{company_id}/{team_id}',
{
  method: 'GET',

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

<?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/calendar/presences/team/{company_id}/{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/calendar/presences/team/{company_id}/{team_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/calendar/presences/team/{company_id}/{team_id}", data)
    req.Header = headers

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

GET /api/v1/calendar/presences/team/{company_id}/{team_id}

Renders count of absences/presences for a given team on a day...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
team_id	path	string	true	team id
date	query	string	false	Date

Example responses

200 Response

{
  "absences": {
    "contracts": {
      "holiday": [
        "92af235f-2d6b-4c86-9519-eedd5a720f89"
      ]
    },
    "details": {
      "holiday": 1
    },
    "total": 1
  },
  "actual_presences": {
    "contracts": [
      "e43114ae-e6d4-4aaf-ab17-39e06f024dd3"
    ],
    "total": 1
  },
  "presences": {
    "contracts": {
      "work": [
        "d29dfab9-d6e4-4587-a2fc-1efbde8f2f83"
      ]
    },
    "details": {
      "work": 1
    },
    "total": 1
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Analytic

Renders all month insertion locks for a given company

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks',
{
  method: 'GET',

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

<?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/calendar/presences/{company_id}/month_insertion_locks', 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/calendar/presences/{company_id}/month_insertion_locks");
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/calendar/presences/{company_id}/month_insertion_locks", data)
    req.Header = headers

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

GET /api/v1/calendar/presences/{company_id}/month_insertion_locks

Renders all month insertion locks for a given company...

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	CompanyMonthInsertionLock

Creates a month insertion lock

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "locked": true,
  "month_number": 0,
  "updated_by": "string",
  "year": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/calendar/presences/{company_id}/month_insertion_locks', 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/calendar/presences/{company_id}/month_insertion_locks");
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/calendar/presences/{company_id}/month_insertion_locks", data)
    req.Header = headers

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

POST /api/v1/calendar/presences/{company_id}/month_insertion_locks

Creates a month insertion lock...

Body parameter

{
  "company_id": "string",
  "locked": true,
  "month_number": 0,
  "updated_by": "string",
  "year": 0
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
body	body	CompanyMonthInsertionLock	false	company_month_insertion_lock attributes

Example responses

201 Response

Responses

Status	Meaning	Description	Schema
201	Created	Success	CompanyMonthInsertionLock
401	Unauthorized	Unauthorized	Unauthorized

Renders month insertion locks config for a given company

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/config \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/config HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/config', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/config',
{
  method: 'GET',

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

<?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/calendar/presences/{company_id}/month_insertion_locks/config', 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/calendar/presences/{company_id}/month_insertion_locks/config");
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/calendar/presences/{company_id}/month_insertion_locks/config", data)
    req.Header = headers

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

GET /api/v1/calendar/presences/{company_id}/month_insertion_locks/config

Renders month insertion locks config for a given company...

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	MonthInsertionLocksConfig

Updates month insertion locks config for a given company

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/config \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/config HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/config', headers = headers)

print(r.json())

const inputBody = '{
  "auto_lock_day": 0,
  "auto_lock_enabled": true,
  "company_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/config',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/calendar/presences/{company_id}/month_insertion_locks/config', 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/calendar/presences/{company_id}/month_insertion_locks/config");
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/calendar/presences/{company_id}/month_insertion_locks/config", data)
    req.Header = headers

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

PUT /api/v1/calendar/presences/{company_id}/month_insertion_locks/config

Updates month insertion locks config for a given company...

Body parameter

{
  "auto_lock_day": 0,
  "auto_lock_enabled": true,
  "company_id": "string"
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company Id
body	body	MonthInsertionLocksConfig	false	month_insertion_locks_config attributes

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Unauthorized	Unauthorized
202	Accepted	Accepted	None

Renders month insertion lock for the current month

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/current \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/current HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/current', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/current',
{
  method: 'GET',

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

<?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/calendar/presences/{company_id}/month_insertion_locks/current', 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/calendar/presences/{company_id}/month_insertion_locks/current");
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/calendar/presences/{company_id}/month_insertion_locks/current", data)
    req.Header = headers

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

GET /api/v1/calendar/presences/{company_id}/month_insertion_locks/current

Renders month insertion lock for the current month...

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	CompanyMonthInsertionLock

Renders month insertion lock in a given period

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/detail \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/detail HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/detail', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/detail',
{
  method: 'GET',

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

<?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/calendar/presences/{company_id}/month_insertion_locks/detail', 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/calendar/presences/{company_id}/month_insertion_locks/detail");
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/calendar/presences/{company_id}/month_insertion_locks/detail", data)
    req.Header = headers

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

GET /api/v1/calendar/presences/{company_id}/month_insertion_locks/detail

Renders month insertion lock in a given period...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
year	query	number	false	Year
month_number	query	number	false	Month

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	CompanyMonthInsertionLock

Updates a month insertion lock

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "locked": true,
  "month_number": 0,
  "updated_by": "string",
  "year": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/presences/{company_id}/month_insertion_locks/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/calendar/presences/{company_id}/month_insertion_locks/{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/calendar/presences/{company_id}/month_insertion_locks/{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/calendar/presences/{company_id}/month_insertion_locks/{id}", data)
    req.Header = headers

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

PUT /api/v1/calendar/presences/{company_id}/month_insertion_locks/{id}

Updates a month insertion lock...

Body parameter

{
  "company_id": "string",
  "locked": true,
  "month_number": 0,
  "updated_by": "string",
  "year": 0
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	month_insertion_lock id
body	body	CompanyMonthInsertionLock	false	company_month_insertion_lock attributes

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	CompanyMonthInsertionLock
401	Unauthorized	Unauthorized	Unauthorized

Renders Public Holidays list

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/public_holidays?country=string&year=string \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/public_holidays?country=string&year=string HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/public_holidays', params={
  'country': 'string',  'year': 'string'
}, headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/public_holidays?country=string&year=string',
{
  method: 'GET',

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

<?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/calendar/public_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/calendar/public_holidays?country=string&year=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/calendar/public_holidays", data)
    req.Header = headers

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

GET /api/v1/calendar/public_holidays

Renders public holidays list for a given country in a given year

Parameters

Name	In	Type	Required	Description
country	query	string	true	Country ISO Code
year	query	string	true	Year

Example responses

200 Response

[
  {
    "end_date": "2019-08-24",
    "name": "string",
    "start_date": "2019-08-24"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	PublicHolidays

Renders a list of working days for a given subsidiary in a range of days

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/subsidiary/{company_id}/{subsidiary_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/subsidiary/{company_id}/{subsidiary_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/subsidiary/{company_id}/{subsidiary_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/subsidiary/{company_id}/{subsidiary_id}',
{
  method: 'GET',

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

<?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/calendar/subsidiary/{company_id}/{subsidiary_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/calendar/subsidiary/{company_id}/{subsidiary_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/calendar/subsidiary/{company_id}/{subsidiary_id}", data)
    req.Header = headers

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

GET /api/v1/calendar/subsidiary/{company_id}/{subsidiary_id}

Renders a list of working days for a given subsidiary in a range of days...

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

[
  {
    "company_id": "7304803f-054c-4aab-9b81-06f7cb286aaf",
    "contract_id": "b20614b4-9c66-4369-85db-079b52b3dffd",
    "day": {
      "calendar": "Elixir.Calendar.ISO",
      "day": 15,
      "month": 7,
      "year": 2024
    },
    "is_company_holiday": false,
    "is_flexible": false,
    "is_subsidiary_holiday": false,
    "is_worker_holiday": false,
    "schedule": [
      {
        "duration_rounding": 1,
        "end": "08:59:59",
        "fixed_end": "09:00:00",
        "flexible": false,
        "presence": false,
        "start": "00:00:00",
        "workplace": {}
      },
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 240,
        "duration_rounding": 1,
        "end": "12:59:59",
        "fixed_end": "13:00:00",
        "flexible": false,
        "last_update": "2022-02-01T23:00:04+00:00",
        "presence": true,
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "start": "09:00:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "duration_rounding": 1,
        "end": "13:59:59",
        "fixed_end": "14:00:00",
        "flexible": false,
        "presence": false,
        "start": "13:00:00",
        "workplace": {}
      },
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 240,
        "duration_rounding": 1,
        "end": "17:59:59",
        "fixed_end": "18:00:00",
        "flexible": false,
        "last_update": "2022-02-01T23:00:04+00:00",
        "presence": true,
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "start": "14:00:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "duration_rounding": 1,
        "end": "23:59:59",
        "fixed_end": "00:00:00",
        "flexible": false,
        "presence": false,
        "start": "18:00:00",
        "workplace": {}
      }
    ],
    "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
    "subsidiary_id": "c1cb3c2b-b0cc-43e0-b318-d0828f8ca298",
    "team_ids": [
      "cbe81e5d-1dc9-45da-93bb-545bbe4d5886"
    ],
    "user_id": "fc044fe9-9dd6-4a11-99a7-66404e556008"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	CalendarEntries

Creates a subsidiary holiday

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/calendar/subsidiary_holidays \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/calendar/subsidiary_holidays HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/calendar/subsidiary_holidays', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "day": "string",
  "name": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "subsidiary_id": "string",
  "to_day": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/subsidiary_holidays',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/calendar/subsidiary_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/calendar/subsidiary_holidays");
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/calendar/subsidiary_holidays", data)
    req.Header = headers

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

POST /api/v1/calendar/subsidiary_holidays

Creates a subsidiary holiday...

Body parameter

{
  "company_id": "string",
  "day": "string",
  "name": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "subsidiary_id": "string",
  "to_day": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	SubsidiaryHoliday	false	holiday attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Deletes a subsidiary holiday

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/calendar/subsidiary_holidays/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/calendar/subsidiary_holidays/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/calendar/subsidiary_holidays/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/subsidiary_holidays/{id}',
{
  method: 'DELETE',

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

<?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/calendar/subsidiary_holidays/{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/calendar/subsidiary_holidays/{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/calendar/subsidiary_holidays/{id}", data)
    req.Header = headers

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

DELETE /api/v1/calendar/subsidiary_holidays/{id}

Deletes a subsidiary holiday...

Parameters

Name	In	Type	Required	Description
id	path	string	true	company id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Updates a subsidiary holiday

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/calendar/subsidiary_holidays/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/calendar/subsidiary_holidays/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/calendar/subsidiary_holidays/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "day": "string",
  "name": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "subsidiary_id": "string",
  "to_day": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/subsidiary_holidays/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/calendar/subsidiary_holidays/{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/calendar/subsidiary_holidays/{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/calendar/subsidiary_holidays/{id}", data)
    req.Header = headers

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

PUT /api/v1/calendar/subsidiary_holidays/{id}

Updates a subsidiary holiday...

Body parameter

{
  "company_id": "string",
  "day": "string",
  "name": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "subsidiary_id": "string",
  "to_day": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	company id
body	body	SubsidiaryHoliday	false	holiday attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of working days for a given team in a range of days

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/calendar/team/{company_id}/{team_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/calendar/team/{company_id}/{team_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/calendar/team/{company_id}/{team_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/calendar/team/{company_id}/{team_id}',
{
  method: 'GET',

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

<?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/calendar/team/{company_id}/{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/calendar/team/{company_id}/{team_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/calendar/team/{company_id}/{team_id}", data)
    req.Header = headers

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

GET /api/v1/calendar/team/{company_id}/{team_id}

Renders a list of working days for a given team in a range of days...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
team_id	path	string	true	team id
start_date	query	string	false	Start date
end_date	query	string	false	End date

Example responses

200 Response

[
  {
    "company_id": "7304803f-054c-4aab-9b81-06f7cb286aaf",
    "contract_id": "b20614b4-9c66-4369-85db-079b52b3dffd",
    "day": {
      "calendar": "Elixir.Calendar.ISO",
      "day": 15,
      "month": 7,
      "year": 2024
    },
    "is_company_holiday": false,
    "is_flexible": false,
    "is_subsidiary_holiday": false,
    "is_worker_holiday": false,
    "schedule": [
      {
        "duration_rounding": 1,
        "end": "08:59:59",
        "fixed_end": "09:00:00",
        "flexible": false,
        "presence": false,
        "start": "00:00:00",
        "workplace": {}
      },
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 240,
        "duration_rounding": 1,
        "end": "12:59:59",
        "fixed_end": "13:00:00",
        "flexible": false,
        "last_update": "2022-02-01T23:00:04+00:00",
        "presence": true,
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "start": "09:00:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "duration_rounding": 1,
        "end": "13:59:59",
        "fixed_end": "14:00:00",
        "flexible": false,
        "presence": false,
        "start": "13:00:00",
        "workplace": {}
      },
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 240,
        "duration_rounding": 1,
        "end": "17:59:59",
        "fixed_end": "18:00:00",
        "flexible": false,
        "last_update": "2022-02-01T23:00:04+00:00",
        "presence": true,
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "start": "14:00:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "duration_rounding": 1,
        "end": "23:59:59",
        "fixed_end": "00:00:00",
        "flexible": false,
        "presence": false,
        "start": "18:00:00",
        "workplace": {}
      }
    ],
    "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
    "subsidiary_id": "c1cb3c2b-b0cc-43e0-b318-d0828f8ca298",
    "team_ids": [
      "cbe81e5d-1dc9-45da-93bb-545bbe4d5886"
    ],
    "user_id": "fc044fe9-9dd6-4a11-99a7-66404e556008"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	CalendarEntries

Renders contracts activity summary for a given company

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contract_activities/by_company/{company_id}/summary \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contract_activities/by_company/{company_id}/summary HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contract_activities/by_company/{company_id}/summary', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contract_activities/by_company/{company_id}/summary',
{
  method: 'GET',

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

<?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/contract_activities/by_company/{company_id}/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/contract_activities/by_company/{company_id}/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/contract_activities/by_company/{company_id}/summary", data)
    req.Header = headers

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

GET /api/v1/contract_activities/by_company/{company_id}/summary

Renders contracts activity summary for a given company

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company Id
date	query	string	false	Date
team_ids	query	array[string]	false	Team Ids
subsidiary_ids	query	array[string]	false	Subsidiary Ids

Example responses

200 Response

{
  "company_id": "string",
  "contract_id": "string",
  "day": "2019-08-24",
  "subsidiary_id": "string",
  "summary": "string",
  "team_ids": [
    "string"
  ],
  "updated_by": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractActivitySummary

Renders contracts activity summary for a given contract

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary',
{
  method: 'GET',

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

<?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/contract_activities/contract/{contract_id}/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/contract_activities/contract/{contract_id}/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/contract_activities/contract/{contract_id}/summary", data)
    req.Header = headers

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

GET /api/v1/contract_activities/contract/{contract_id}/summary

Renders contracts activity summary for a given contract

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
date	query	string	false	Date

Example responses

200 Response

{
  "company_id": "string",
  "contract_id": "string",
  "day": "2019-08-24",
  "subsidiary_id": "string",
  "summary": "string",
  "team_ids": [
    "string"
  ],
  "updated_by": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractActivitySummary

Creates a contract activity summary

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "contract_id": "string",
  "day": "2019-08-24",
  "subsidiary_id": "string",
  "summary": "string",
  "team_ids": [
    "string"
  ],
  "updated_by": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/contract_activities/contract/{contract_id}/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/contract_activities/contract/{contract_id}/summary");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary", data)
    req.Header = headers

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

POST /api/v1/contract_activities/contract/{contract_id}/summary

Creates a contract activity summary for a given contract

Body parameter

{
  "company_id": "string",
  "contract_id": "string",
  "day": "2019-08-24",
  "subsidiary_id": "string",
  "summary": "string",
  "team_ids": [
    "string"
  ],
  "updated_by": "string"
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
body	body	ContractActivitySummary	false	contract_activity_summary attributes

Example responses

401 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Updates a contract activity summary

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "contract_id": "string",
  "day": "2019-08-24",
  "subsidiary_id": "string",
  "summary": "string",
  "team_ids": [
    "string"
  ],
  "updated_by": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/contract_activities/contract/{contract_id}/summary/{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/contract_activities/contract/{contract_id}/summary/{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{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/contract_activities/contract/{contract_id}/summary/{id}", data)
    req.Header = headers

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

PUT /api/v1/contract_activities/contract/{contract_id}/summary/{id}

Updates contracts activity summary for a given contract

Body parameter

{
  "company_id": "string",
  "contract_id": "string",
  "day": "2019-08-24",
  "subsidiary_id": "string",
  "summary": "string",
  "team_ids": [
    "string"
  ],
  "updated_by": "string"
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
id	path	string	true	activity id
body	body	ContractActivitySummary	false	contract_activity_summary attributes

Example responses

401 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of working days for chosen contract

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contracts/{contract_id}/calendar \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contracts/{contract_id}/calendar HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contracts/{contract_id}/calendar', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{contract_id}/calendar',
{
  method: 'GET',

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

<?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/contracts/{contract_id}/calendar', 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/contracts/{contract_id}/calendar");
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/contracts/{contract_id}/calendar", data)
    req.Header = headers

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

GET /api/v1/contracts/{contract_id}/calendar

Renders a list of working days for chosen contract

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
start_date	query	string	false	Start date
end_date	query	string	false	End date

Example responses

200 Response

[
  {
    "actual_calendar": [
      {
        "additive": false,
        "duration_rounding": 1,
        "end": "08:59:59",
        "end_datetime": "2022-02-01T08:59:59+01:00",
        "fixed": false,
        "fixed_end": "09:00:00",
        "mismatched": false,
        "overnight": false,
        "presence": false,
        "start": "00:00:00",
        "start_datetime": "2022-02-01T00:00:00+01:00",
        "workplace": {}
      },
      {
        "additive": false,
        "duration": 240,
        "duration_rounding": 1,
        "end": "12:59:59",
        "end_datetime": "2022-02-01T12:59:59+01:00",
        "fixed": false,
        "fixed_end": "13:00:00",
        "mismatch_reason": "time_mismatch",
        "mismatched": true,
        "original_id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "overnight": false,
        "presence": false,
        "start": "09:00:00",
        "start_datetime": "2022-02-01T09:00:00+01:00",
        "subsidiary_id": "9b945939-8452-43f7-bead-408798febf58",
        "type_label": "mismatched_absence",
        "type_name": "COMMON.MISMATCHED_ABSENCE",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "additive": false,
        "duration": 60,
        "duration_rounding": 1,
        "end": "13:59:59",
        "end_datetime": "2022-02-01T13:59:59+01:00",
        "fixed": false,
        "fixed_end": "14:00:00",
        "mismatched": false,
        "overnight": false,
        "presence": false,
        "start": "13:00:00",
        "start_datetime": "2022-02-01T13:00:00+01:00",
        "subsidiary_id": "9b945939-8452-43f7-bead-408798febf58",
        "type_label": "break",
        "workplace": {}
      },
      {
        "additive": false,
        "duration": 240,
        "duration_rounding": 1,
        "end": "17:59:59",
        "end_datetime": "2022-02-01T17:59:59+01:00",
        "fixed": false,
        "fixed_end": "18:00:00",
        "mismatch_reason": "time_mismatch",
        "mismatched": true,
        "original_id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "overnight": false,
        "presence": false,
        "start": "14:00:00",
        "start_datetime": "2022-02-01T14:00:00+01:00",
        "subsidiary_id": "9b945939-8452-43f7-bead-408798febf58",
        "type_label": "mismatched_absence",
        "type_name": "COMMON.MISMATCHED_ABSENCE",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "additive": false,
        "duration_rounding": 1,
        "end": "23:59:59",
        "end_datetime": "2022-02-01T23:59:59+01:00",
        "fixed": false,
        "fixed_end": "00:00:00",
        "mismatched": false,
        "overnight": false,
        "presence": false,
        "start": "18:00:00",
        "start_datetime": "2022-02-01T18:00:00+01:00",
        "workplace": {}
      }
    ],
    "actual_extra_time_minutes": 4,
    "actual_regular_work_minutes": 3,
    "company_id": "354621d2-b1f3-4b20-b164-8165a67d3b8d",
    "contract_clocking_duty": "never",
    "contract_id": "64633a6f-1138-4f88-88f0-9426641fdc35",
    "day": "2024-07-15",
    "expected_extra_time_minutes": 2,
    "expected_regular_work_minutes": 0,
    "flexible_actual_calendar": [
      {
        "additive": false,
        "duration": 480,
        "duration_rounding": 1,
        "fixed": false,
        "mismatch_reason": "time_mismatch",
        "mismatched": true,
        "presence": false,
        "type_label": "mismatched_absence",
        "type_name": "COMMON.MISMATCHED_ABSENCE",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      }
    ],
    "flexible_schedule": [
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 480,
        "duration_rounding": 1,
        "flexible": false,
        "id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "last_update": "2022-02-01T05:37:18+00:00",
        "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "presence": true,
        "requested_at": "2022-02-01T05:37:15+00:00",
        "requested_by": "77589503-3daf-4359-b52b-3e295920b001",
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      }
    ],
    "is_company_holiday": false,
    "is_flexible": true,
    "is_subsidiary_holiday": false,
    "is_worker_holiday": false,
    "mismatched_absence_minutes": 4,
    "mismatched_work_minutes": 4,
    "mismatches": [
      {
        "duration": 240,
        "end": "12:59:59",
        "end_datetime": "2022-02-01T12:59:59+01:00",
        "fixed_end": "13:00:00",
        "is_on_interval": true,
        "mismatch_reason": "time_mismatch",
        "overnight": false,
        "start": "09:00:00",
        "start_datetime": "2022-02-01T09:00:00+01:00",
        "type": "mismatched_absence"
      },
      {
        "duration": 240,
        "end": "17:59:59",
        "end_datetime": "2022-02-01T17:59:59+01:00",
        "fixed_end": "18:00:00",
        "is_on_interval": true,
        "mismatch_reason": "time_mismatch",
        "overnight": false,
        "start": "14:00:00",
        "start_datetime": "2022-02-01T14:00:00+01:00",
        "type": "mismatched_absence"
      }
    ],
    "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
    "presence_entries": [
      {
        "complete": false,
        "datetime": "2024-07-15T13:26:47.387512Z",
        "direction": "IN",
        "id": "5186d5f4-1fab-46ac-88a5-22243f60a9a0",
        "last_update": "2024-07-15T13:26:47.387505Z",
        "start": "09:00:00",
        "start_datetime": "2024-07-15T13:26:47.387514Z",
        "status": "recorded",
        "subsidiary_id": "97a5ae37-52dd-4443-96ca-1647f69b61c3",
        "time": "09:00:00",
        "timezone": "Europe/Rome"
      },
      {
        "complete": false,
        "datetime": "2024-07-15T13:26:47.387524Z",
        "direction": "OUT",
        "end": "13:00:00",
        "end_datetime": "2024-07-15T13:26:47.387526Z",
        "id": "0eef68dd-e10a-41da-a68f-0738a11b8814",
        "last_update": "2024-07-15T13:26:47.387523Z",
        "status": "recorded",
        "subsidiary_id": "b7be5e06-73c1-47bc-a0f9-85d16ce4cf26",
        "time": "13:00:00",
        "timezone": "Europe/Rome"
      }
    ],
    "schedule": [
      {
        "duration_rounding": 1,
        "end": "08:59:59",
        "fixed_end": "09:00:00",
        "flexible": false,
        "presence": false,
        "start": "00:00:00",
        "workplace": {}
      },
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 240,
        "duration_rounding": 1,
        "end": "12:59:59",
        "fixed_end": "13:00:00",
        "flexible": false,
        "id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "last_update": "2022-02-01T05:37:18+00:00",
        "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "presence": true,
        "requested_at": "2022-02-01T05:37:15+00:00",
        "requested_by": "77589503-3daf-4359-b52b-3e295920b001",
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "start": "09:00:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "duration_rounding": 1,
        "end": "13:59:59",
        "fixed_end": "14:00:00",
        "flexible": false,
        "presence": false,
        "start": "13:00:00",
        "workplace": {}
      },
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 240,
        "duration_rounding": 1,
        "end": "17:59:59",
        "fixed_end": "18:00:00",
        "flexible": false,
        "id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "last_update": "2022-02-01T05:37:18+00:00",
        "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "presence": true,
        "requested_at": "2022-02-01T05:37:15+00:00",
        "requested_by": "77589503-3daf-4359-b52b-3e295920b001",
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "start": "14:00:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      },
      {
        "duration_rounding": 1,
        "end": "23:59:59",
        "fixed_end": "00:00:00",
        "flexible": false,
        "presence": false,
        "start": "18:00:00",
        "workplace": {}
      }
    ],
    "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
    "shift_override_id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
    "shift_override_type": "daily",
    "squaring_enabled": true,
    "subsidiary_id": "2df45501-d3c7-43e3-a423-e5033d5b1fa7",
    "subsidiary_ids": [
      "aff8aa52-7e7f-4a79-9b68-c920987945da"
    ],
    "summary": {
      "absences": {
        "details": [],
        "duration": 0
      },
      "day": "2022-02-01",
      "extraordinary": {
        "details": [],
        "duration": 0
      },
      "is_company_holiday": false,
      "is_day_off": false,
      "is_subsidiary_holiday": false,
      "is_worker_holiday": false,
      "mismatched": false,
      "mismatches": {
        "details": [],
        "duration": 0
      },
      "presences": {
        "details": [
          {
            "duration": 480,
            "presence": true,
            "type_label": "work",
            "type_name": "work"
          }
        ],
        "duration": 480
      }
    },
    "team_ids": [
      "3fe6706e-ac1c-4328-9809-8507f9e41990"
    ],
    "timezone": "Etc/UTC",
    "user_id": "85ed9695-b92c-4fc6-a597-e7d702ddf70e"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	ActualCalendarEntries

Renders a list of working days for chosen contract in a lightweight version

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contracts/{contract_id}/calendar/light \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contracts/{contract_id}/calendar/light HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contracts/{contract_id}/calendar/light', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{contract_id}/calendar/light',
{
  method: 'GET',

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

<?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/contracts/{contract_id}/calendar/light', 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/contracts/{contract_id}/calendar/light");
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/contracts/{contract_id}/calendar/light", data)
    req.Header = headers

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

GET /api/v1/contracts/{contract_id}/calendar/light

Renders a list of working days for chosen contract in a lightweight version optimized for mobile apps

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
start_date	query	string	false	Start date
end_date	query	string	false	End date

Example responses

200 Response

[
  {
    "actual_calendar": [
      {
        "additive": false,
        "duration": 480,
        "duration_rounding": 1,
        "fixed": false,
        "mismatch_reason": "time_mismatch",
        "mismatched": true,
        "presence": false,
        "type_label": "mismatched_absence",
        "type_name": "COMMON.MISMATCHED_ABSENCE",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      }
    ],
    "company_id": "e7ce8140-8dce-4dd2-bfd4-25ee09b9fee5",
    "contract_clocking_duty": "never",
    "contract_id": "b031b69a-349b-4a69-b73b-f2a60ef274e2",
    "day": "2024-07-15",
    "is_company_holiday": false,
    "is_flexible": true,
    "is_subsidiary_holiday": false,
    "is_worker_holiday": false,
    "mismatches": [
      {
        "duration": 240,
        "end": "12:59:59",
        "end_datetime": "2022-02-01T12:59:59+01:00",
        "fixed_end": "13:00:00",
        "is_on_interval": true,
        "mismatch_reason": "time_mismatch",
        "overnight": false,
        "start": "09:00:00",
        "start_datetime": "2022-02-01T09:00:00+01:00",
        "type": "mismatched_absence"
      },
      {
        "duration": 240,
        "end": "17:59:59",
        "end_datetime": "2022-02-01T17:59:59+01:00",
        "fixed_end": "18:00:00",
        "is_on_interval": true,
        "mismatch_reason": "time_mismatch",
        "overnight": false,
        "start": "14:00:00",
        "start_datetime": "2022-02-01T14:00:00+01:00",
        "type": "mismatched_absence"
      }
    ],
    "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
    "schedule": [
      {
        "daily_schedule_id": "78ce4e20-510c-49d3-99bf-3805d10b6de6",
        "duration": 480,
        "duration_rounding": 1,
        "flexible": false,
        "id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
        "last_update": "2022-02-01T05:37:18+00:00",
        "overrided_shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "presence": true,
        "requested_at": "2022-02-01T05:37:15+00:00",
        "requested_by": "77589503-3daf-4359-b52b-3e295920b001",
        "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
        "type_label": "work",
        "type_name": "work",
        "workplace": {
          "id": "9b945939-8452-43f7-bead-408798febf58",
          "label": "subsidiary",
          "type": "subsidiary"
        }
      }
    ],
    "shift_name": "09:00 > 13:00 | 14:00 > 18:00",
    "shift_override_id": "25d3f122-a874-4832-a0ee-9e31cce44e9b",
    "shift_override_type": "daily",
    "squaring_enabled": true,
    "subsidiary_id": "ec275740-9614-49c6-bceb-6b1af252087c",
    "subsidiary_ids": [
      "bac2764f-0d0d-422a-b087-52e5cee88f3b"
    ],
    "team_ids": [
      "71a45d43-a028-4350-a351-11a49eb76e7e"
    ],
    "timezone": "Etc/UTC",
    "user_id": "13caf1aa-f1e0-4a55-8f74-91b12323ad61"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	LightActualCalendarEntries

Renders a justification duration for given days

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contracts/{contract_id}/justifications/{justification_id}/duration \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contracts/{contract_id}/justifications/{justification_id}/duration HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contracts/{contract_id}/justifications/{justification_id}/duration', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{contract_id}/justifications/{justification_id}/duration',
{
  method: 'GET',

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

<?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/contracts/{contract_id}/justifications/{justification_id}/duration', 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/contracts/{contract_id}/justifications/{justification_id}/duration");
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/contracts/{contract_id}/justifications/{justification_id}/duration", data)
    req.Header = headers

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

GET /api/v1/contracts/{contract_id}/justifications/{justification_id}/duration

Renders a justification duration for given days...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
justification_id	path	string	true	contract id
start_date	query	string	false	Start date
end_date	query	string	false	End date

Example responses

200 Response

{
  "duration": 60
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	JustificationDuration

Snoozes a contract reminder

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/contract/{contract_id}/snooze_reminder \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/contract/{contract_id}/snooze_reminder HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/contract/{contract_id}/snooze_reminder', headers = headers)

print(r.json())

const inputBody = '{
  "reminder": "missed_activity_summary",
  "snooze_datetime": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/contract/{contract_id}/snooze_reminder',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/contract/{contract_id}/snooze_reminder', 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/contract/{contract_id}/snooze_reminder");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/contract/{contract_id}/snooze_reminder", data)
    req.Header = headers

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

PUT /contract/{contract_id}/snooze_reminder

Snoozes the giver reminder for the given contract

Body parameter

{
  "reminder": "missed_activity_summary",
  "snooze_datetime": "string"
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
body	body	SnoozeReminder	false	Request body

Example responses

401 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Gives subsidiary infos about the planned subsidiary at given date/time

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/contracts/{contract_id}/planned_subsidiary/date/{stamping_date}/time/{stamping_time}/direction/{direction} \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/contracts/{contract_id}/planned_subsidiary/date/{stamping_date}/time/{stamping_time}/direction/{direction} HTTP/1.1
Host: api.fluida.io

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/contracts/{contract_id}/planned_subsidiary/date/{stamping_date}/time/{stamping_time}/direction/{direction}', headers = headers)

print(r.json())

const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/contracts/{contract_id}/planned_subsidiary/date/{stamping_date}/time/{stamping_time}/direction/{direction}',
{
  method: 'GET',

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

<?php

require 'vendor/autoload.php';

$headers = array(
    '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/contracts/{contract_id}/planned_subsidiary/date/{stamping_date}/time/{stamping_time}/direction/{direction}', 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/contracts/{contract_id}/planned_subsidiary/date/{stamping_date}/time/{stamping_time}/direction/{direction}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/contracts/{contract_id}/planned_subsidiary/date/{stamping_date}/time/{stamping_time}/direction/{direction}", data)
    req.Header = headers

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

GET /contracts/{contract_id}/planned_subsidiary/date/{stamping_date}/time/{stamping_time}/direction/{direction}

Subsidiary could also be remote, or 404 in case of no shift planned

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	Contrat id
stamping_date	path	string(date)	true	Date
stamping_time	path	string	true	Time
direction	path	string	true	Direction

Responses

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

Company

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: */*

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())

const inputBody = '{
  "address": "14138 Cummerata Brooks",
  "admin_user_email": "company-admin-0@example.com",
  "admin_user_id": "ca344b9d-c0ec-4e18-b528-cea10431c7cd",
  "billing_email": "billing-1@example.com",
  "city": "Ritchieberg",
  "codice_destinatario": "000000",
  "country": "Lithuania",
  "fiscal_code": "ABCDEF12A01H501-1",
  "id": "cbf4e570-7415-4f35-96f1-5e63000a1c3b",
  "location_info": {
    "lat": "43",
    "long": "0"
  },
  "name": "Marks-Kemmer",
  "number_of_employees": 20,
  "pec": "foo.bar@pec.it",
  "phone": "07881 836703",
  "plan_quantity": 10,
  "preferences": {
    "stamping_enabled": "true"
  },
  "province": "TO",
  "subscribed_features": [
    "export"
  ],
  "subscription_customer_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_expiration_date": "2019-09-30T00:00:00Z",
  "subscription_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_plan": "started",
  "subscription_status": "active",
  "timezone": "Europe/Rome",
  "trial_expiration_date": "2019-07-30T00:00:00Z",
  "vat": "123456789-0",
  "zip": "92328"
}';
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);
});

<?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

{
  "address": "14138 Cummerata Brooks",
  "admin_user_email": "company-admin-0@example.com",
  "admin_user_id": "ca344b9d-c0ec-4e18-b528-cea10431c7cd",
  "billing_email": "billing-1@example.com",
  "city": "Ritchieberg",
  "codice_destinatario": "000000",
  "country": "Lithuania",
  "fiscal_code": "ABCDEF12A01H501-1",
  "id": "cbf4e570-7415-4f35-96f1-5e63000a1c3b",
  "location_info": {
    "lat": "43",
    "long": "0"
  },
  "name": "Marks-Kemmer",
  "number_of_employees": 20,
  "pec": "foo.bar@pec.it",
  "phone": "07881 836703",
  "plan_quantity": 10,
  "preferences": {
    "stamping_enabled": "true"
  },
  "province": "TO",
  "subscribed_features": [
    "export"
  ],
  "subscription_customer_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_expiration_date": "2019-09-30T00:00:00Z",
  "subscription_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_plan": "started",
  "subscription_status": "active",
  "timezone": "Europe/Rome",
  "trial_expiration_date": "2019-07-30T00:00:00Z",
  "vat": "123456789-0",
  "zip": "92328"
}

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

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

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())

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);
});

<?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

{
  "address": "14138 Cummerata Brooks",
  "admin_user_email": "company-admin-0@example.com",
  "admin_user_id": "ca344b9d-c0ec-4e18-b528-cea10431c7cd",
  "billing_email": "billing-1@example.com",
  "city": "Ritchieberg",
  "codice_destinatario": "000000",
  "country": "Lithuania",
  "fiscal_code": "ABCDEF12A01H501-1",
  "id": "cbf4e570-7415-4f35-96f1-5e63000a1c3b",
  "location_info": {
    "lat": "43",
    "long": "0"
  },
  "name": "Marks-Kemmer",
  "number_of_employees": 20,
  "pec": "foo.bar@pec.it",
  "phone": "07881 836703",
  "plan_quantity": 10,
  "preferences": {
    "stamping_enabled": "true"
  },
  "province": "TO",
  "subscribed_features": [
    "export"
  ],
  "subscription_customer_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_expiration_date": "2019-09-30T00:00:00Z",
  "subscription_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_plan": "started",
  "subscription_status": "active",
  "timezone": "Europe/Rome",
  "trial_expiration_date": "2019-07-30T00:00:00Z",
  "vat": "123456789-0",
  "zip": "92328"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Company

Updates a company

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/{company_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/{company_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/companies/{company_id}', headers = headers)

print(r.json())

const inputBody = '{
  "address": "14138 Cummerata Brooks",
  "admin_user_email": "company-admin-0@example.com",
  "admin_user_id": "ca344b9d-c0ec-4e18-b528-cea10431c7cd",
  "billing_email": "billing-1@example.com",
  "city": "Ritchieberg",
  "codice_destinatario": "000000",
  "country": "Lithuania",
  "fiscal_code": "ABCDEF12A01H501-1",
  "id": "cbf4e570-7415-4f35-96f1-5e63000a1c3b",
  "location_info": {
    "lat": "43",
    "long": "0"
  },
  "name": "Marks-Kemmer",
  "number_of_employees": 20,
  "pec": "foo.bar@pec.it",
  "phone": "07881 836703",
  "plan_quantity": 10,
  "preferences": {
    "stamping_enabled": "true"
  },
  "province": "TO",
  "subscribed_features": [
    "export"
  ],
  "subscription_customer_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_expiration_date": "2019-09-30T00:00:00Z",
  "subscription_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_plan": "started",
  "subscription_status": "active",
  "timezone": "Europe/Rome",
  "trial_expiration_date": "2019-07-30T00:00:00Z",
  "vat": "123456789-0",
  "zip": "92328"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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}', 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{
        "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}", data)
    req.Header = headers

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

PUT /api/v1/companies/{company_id}

Updates a company...

Body parameter

{
  "address": "14138 Cummerata Brooks",
  "admin_user_email": "company-admin-0@example.com",
  "admin_user_id": "ca344b9d-c0ec-4e18-b528-cea10431c7cd",
  "billing_email": "billing-1@example.com",
  "city": "Ritchieberg",
  "codice_destinatario": "000000",
  "country": "Lithuania",
  "fiscal_code": "ABCDEF12A01H501-1",
  "id": "cbf4e570-7415-4f35-96f1-5e63000a1c3b",
  "location_info": {
    "lat": "43",
    "long": "0"
  },
  "name": "Marks-Kemmer",
  "number_of_employees": 20,
  "pec": "foo.bar@pec.it",
  "phone": "07881 836703",
  "plan_quantity": 10,
  "preferences": {
    "stamping_enabled": "true"
  },
  "province": "TO",
  "subscribed_features": [
    "export"
  ],
  "subscription_customer_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_expiration_date": "2019-09-30T00:00:00Z",
  "subscription_id": "1t0Aw18RVMhQ1Z2ELK",
  "subscription_plan": "started",
  "subscription_status": "active",
  "timezone": "Europe/Rome",
  "trial_expiration_date": "2019-07-30T00:00:00Z",
  "vat": "123456789-0",
  "zip": "92328"
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
body	body	Company	false	company attributes

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	Company
401	Unauthorized	Unauthorized	Unauthorized

List activable extensions

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/activable_extensions \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/activable_extensions HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/activable_extensions', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/activable_extensions',
{
  method: 'GET',

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

<?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}/activable_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}/activable_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}/activable_extensions", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/activable_extensions

List fluida extensions activable by company

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
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

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())

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);
});

<?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

[
  {
    "day": "string",
    "is_worker_holiday": true,
    "name": "string",
    "recurrent": "string",
    "recurrent_until": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Holidays

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: */*

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())

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);
});

<?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

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: */*

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())

const inputBody = '{
  "name": "Full access api",
  "scopes": [],
  "type": "full"
}';
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);
});

<?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

{
  "name": "Full access api",
  "scopes": [],
  "type": "full"
}

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

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: */*

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())

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);
});

<?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

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: */*

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())

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);
});

<?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
id	path	string	true	api key id

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ApiKey
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: */*

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())

const inputBody = '{
  "name": "Full access api",
  "scopes": [],
  "type": "full"
}';
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);
});

<?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

{
  "name": "Full access api",
  "scopes": [],
  "type": "full"
}

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

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

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())

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);
});

<?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

[
  {
    "api": "justification",
    "mode": [
      "read",
      "write"
    ],
    "name": "Justification"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Scopes

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: */*

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())

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);
});

<?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

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: */*

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())

const inputBody = '{
  "action_required": "string",
  "attachments": [
    {
      "id": "string",
      "mime": "string",
      "name": "string"
    }
  ],
  "change_log": [
    {}
  ],
  "company_id": "string",
  "destination_contract_ids": [
    "string"
  ],
  "destination_subsidiary_ids": [
    "string"
  ],
  "destination_team_ids": [
    "string"
  ],
  "message": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "send_at": "string",
  "sender_id": "string",
  "status": "string",
  "subject": "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);
});

<?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

{
  "action_required": "string",
  "attachments": [
    {
      "id": "string",
      "mime": "string",
      "name": "string"
    }
  ],
  "change_log": [
    {}
  ],
  "company_id": "string",
  "destination_contract_ids": [
    "string"
  ],
  "destination_subsidiary_ids": [
    "string"
  ],
  "destination_team_ids": [
    "string"
  ],
  "message": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "send_at": "string",
  "sender_id": "string",
  "status": "string",
  "subject": "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

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: */*

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())

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);
});

<?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

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: */*

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())

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);
});

<?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

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: */*

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())

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);
});

<?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 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: */*

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())

const inputBody = '{
  "action_done": "string",
  "action_done_at": "string",
  "opened": true
}';
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);
});

<?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

{
  "action_done": "string",
  "action_done_at": "string",
  "opened": true
}

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

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: */*

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())

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);
});

<?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

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: */*

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())

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);
});

<?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

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: */*

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())

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);
});

<?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

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: */*

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())

const inputBody = '{
  "action_required": "string",
  "attachments": [
    {
      "id": "string",
      "mime": "string",
      "name": "string"
    }
  ],
  "change_log": [
    {}
  ],
  "company_id": "string",
  "destination_contract_ids": [
    "string"
  ],
  "destination_subsidiary_ids": [
    "string"
  ],
  "destination_team_ids": [
    "string"
  ],
  "message": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "send_at": "string",
  "sender_id": "string",
  "status": "string",
  "subject": "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);
});

<?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

{
  "action_required": "string",
  "attachments": [
    {
      "id": "string",
      "mime": "string",
      "name": "string"
    }
  ],
  "change_log": [
    {}
  ],
  "company_id": "string",
  "destination_contract_ids": [
    "string"
  ],
  "destination_subsidiary_ids": [
    "string"
  ],
  "destination_team_ids": [
    "string"
  ],
  "message": "string",
  "recurrent": "string",
  "recurrent_until": "string",
  "send_at": "string",
  "sender_id": "string",
  "status": "string",
  "subject": "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

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: */*

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())

const inputBody = '{
  "contract_id": "string",
  "team_ids": [
    "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);
});

<?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

{
  "contract_id": "string",
  "team_ids": [
    "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

List contracts and pending invites

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/contracts_invites \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/contracts_invites HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/contracts_invites', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/contracts_invites',
{
  method: 'GET',

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

<?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}/contracts_invites', 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_invites");
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}/contracts_invites", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/contracts_invites

Renders a list of contracts and pending invites by company

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company_id
team_ids	query	array[string]	false	Team Ids
subsidiary_ids	query	array[string]	false	Subsidiary Ids
search	query	string	false	search in lastname or firstname
only_active_contracts	query	boolean	false	returns only active contracts
add_presence_status	query	boolean	false	add presence status infos
presence_status	query	array[string]	false	Presence status
page	query	integer	false	the page to return
page_size	query	integer	false	number of records per page

Enumerated Values

Parameter	Value
presence_status	present
presence_status	maybe_present
presence_status	absent

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	CompanyUsersPage
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}/disable \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/{company_id}/disable HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/companies/{company_id}/disable', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/disable',
{
  method: 'PUT',

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

<?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}/disable', 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}/disable");
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}/disable", data)
    req.Header = headers

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

PUT /api/v1/companies/{company_id}/disable

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

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: */*

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())

const inputBody = '{
  "company_id": "string",
  "configuration": {},
  "coupon_code": "string",
  "enabled": true,
  "extension_id": "string",
  "terms_and_conditions": true
}';
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);
});

<?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

{
  "company_id": "string",
  "configuration": {},
  "coupon_code": "string",
  "enabled": true,
  "extension_id": "string",
  "terms_and_conditions": true
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
body	body	CompanyExtensionParams	false	extension attributes

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	CompanyExtension
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: */*

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())

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);
});

<?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

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: */*

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())

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);
});

<?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

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: */*

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())

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);
});

<?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
company_id	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

Get company extension details

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/companies/{company_id}/extensions/{extension_id}/details \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/companies/{company_id}/extensions/{extension_id}/details HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/companies/{company_id}/extensions/{extension_id}/details', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/extensions/{extension_id}/details',
{
  method: 'GET',

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

<?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/{extension_id}/details', 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/{extension_id}/details");
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/{extension_id}/details", data)
    req.Header = headers

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

GET /api/v1/companies/{company_id}/extensions/{extension_id}/details

Get company extension details

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	FluidaExtension
401	Unauthorized	Unauthorized	Unauthorized

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: */*

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())

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);
});

<?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

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

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())

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);
});

<?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

[
  {
    "day": "string",
    "is_worker_holiday": true,
    "name": "string",
    "recurrent": "string",
    "recurrent_until": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Holidays

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

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())

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);
});

<?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

[
  {
    "address": "47395 Gus Unions",
    "capacity": 4,
    "city": "Port Holdenville",
    "company_id": "3a36aea7-7fc8-43fb-ae47-e02222fc42d3",
    "country": "Spain",
    "location_info": {
      "lat": "43",
      "long": "0"
    },
    "name": "Thompson-Emard",
    "province": "South",
    "ref_code": "12390193",
    "timezone": "Europe/Rome",
    "zip": "61290"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Subsidiaries

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: */*

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())

const inputBody = '{
  "address": "47395 Gus Unions",
  "capacity": 4,
  "city": "Port Holdenville",
  "company_id": "3a36aea7-7fc8-43fb-ae47-e02222fc42d3",
  "country": "Spain",
  "location_info": {
    "lat": "43",
    "long": "0"
  },
  "name": "Thompson-Emard",
  "province": "South",
  "ref_code": "12390193",
  "timezone": "Europe/Rome",
  "zip": "61290"
}';
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);
});

<?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

{
  "address": "47395 Gus Unions",
  "capacity": 4,
  "city": "Port Holdenville",
  "company_id": "3a36aea7-7fc8-43fb-ae47-e02222fc42d3",
  "country": "Spain",
  "location_info": {
    "lat": "43",
    "long": "0"
  },
  "name": "Thompson-Emard",
  "province": "South",
  "ref_code": "12390193",
  "timezone": "Europe/Rome",
  "zip": "61290"
}

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
201	Created	Created	None
401	Unauthorized	Unauthorized	Unauthorized

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: */*

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())

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);
});

<?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 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

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())

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);
});

<?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

{
  "address": "47395 Gus Unions",
  "capacity": 4,
  "city": "Port Holdenville",
  "company_id": "3a36aea7-7fc8-43fb-ae47-e02222fc42d3",
  "country": "Spain",
  "location_info": {
    "lat": "43",
    "long": "0"
  },
  "name": "Thompson-Emard",
  "province": "South",
  "ref_code": "12390193",
  "timezone": "Europe/Rome",
  "zip": "61290"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Subsidiary

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: */*

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())

const inputBody = '{
  "address": "47395 Gus Unions",
  "capacity": 4,
  "city": "Port Holdenville",
  "company_id": "3a36aea7-7fc8-43fb-ae47-e02222fc42d3",
  "country": "Spain",
  "location_info": {
    "lat": "43",
    "long": "0"
  },
  "name": "Thompson-Emard",
  "province": "South",
  "ref_code": "12390193",
  "timezone": "Europe/Rome",
  "zip": "61290"
}';
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);
});

<?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

{
  "address": "47395 Gus Unions",
  "capacity": 4,
  "city": "Port Holdenville",
  "company_id": "3a36aea7-7fc8-43fb-ae47-e02222fc42d3",
  "country": "Spain",
  "location_info": {
    "lat": "43",
    "long": "0"
  },
  "name": "Thompson-Emard",
  "province": "South",
  "ref_code": "12390193",
  "timezone": "Europe/Rome",
  "zip": "61290"
}

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 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

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())

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);
});

<?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

[
  {
    "day": "string",
    "is_worker_holiday": true,
    "name": "string",
    "recurrent": "string",
    "recurrent_until": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Holidays

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

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())

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);
});

<?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

[
  {
    "day": "string",
    "is_worker_holiday": true,
    "name": "string",
    "recurrent": "string",
    "recurrent_until": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Holidays

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

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())

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);
});

<?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

{
  "company_id": "string",
  "subsidiary_id": "string",
  "weekday": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	SubsidiaryWeeklyClosingDays

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: */*

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())

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);
});

<?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

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: */*

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())

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);
});

<?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

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

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())

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);
});

<?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

[
  {
    "company_id": "e2582b0e-a1a6-4bce-af3a-4ff68e73979f",
    "name": "Thompson-Emard",
    "subsidiary_id": "135cd78d-9b93-4cab-86b8-2cf94b8d1de2",
    "team_leader_ids": [
      "c933f051-c8fd-48aa-b6e3-7537652cb4c4",
      "6fb77275-c459-4400-b8d0-7f8668958660"
    ]
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Teams

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: */*

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())

const inputBody = '{
  "company_id": "e2582b0e-a1a6-4bce-af3a-4ff68e73979f",
  "name": "Thompson-Emard",
  "subsidiary_id": "135cd78d-9b93-4cab-86b8-2cf94b8d1de2",
  "team_leader_ids": [
    "c933f051-c8fd-48aa-b6e3-7537652cb4c4",
    "6fb77275-c459-4400-b8d0-7f8668958660"
  ]
}';
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);
});

<?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

{
  "company_id": "e2582b0e-a1a6-4bce-af3a-4ff68e73979f",
  "name": "Thompson-Emard",
  "subsidiary_id": "135cd78d-9b93-4cab-86b8-2cf94b8d1de2",
  "team_leader_ids": [
    "c933f051-c8fd-48aa-b6e3-7537652cb4c4",
    "6fb77275-c459-4400-b8d0-7f8668958660"
  ]
}

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

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: */*

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())

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);
});

<?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

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

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())

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);
});

<?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

{
  "company_id": "e2582b0e-a1a6-4bce-af3a-4ff68e73979f",
  "name": "Thompson-Emard",
  "subsidiary_id": "135cd78d-9b93-4cab-86b8-2cf94b8d1de2",
  "team_leader_ids": [
    "c933f051-c8fd-48aa-b6e3-7537652cb4c4",
    "6fb77275-c459-4400-b8d0-7f8668958660"
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Team

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/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/{company_id}/teams/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

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/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "e2582b0e-a1a6-4bce-af3a-4ff68e73979f",
  "name": "Thompson-Emard",
  "subsidiary_id": "135cd78d-9b93-4cab-86b8-2cf94b8d1de2",
  "team_leader_ids": [
    "c933f051-c8fd-48aa-b6e3-7537652cb4c4",
    "6fb77275-c459-4400-b8d0-7f8668958660"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/teams/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/{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("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/{id}", data)
    req.Header = headers

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

PUT /api/v1/companies/{company_id}/teams/{id}

Updates a teams for a given company...

Body parameter

{
  "company_id": "e2582b0e-a1a6-4bce-af3a-4ff68e73979f",
  "name": "Thompson-Emard",
  "subsidiary_id": "135cd78d-9b93-4cab-86b8-2cf94b8d1de2",
  "team_leader_ids": [
    "c933f051-c8fd-48aa-b6e3-7537652cb4c4",
    "6fb77275-c459-4400-b8d0-7f8668958660"
  ]
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
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

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: */*

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())

const inputBody = '{
  "contract_id": "string",
  "team_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);
});

<?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

{
  "contract_id": "string",
  "team_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

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: */*

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())

const inputBody = '{
  "contract_id": "string",
  "team_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);
});

<?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

{
  "contract_id": "string",
  "team_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

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: */*

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())

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);
});

<?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

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: */*

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())

const inputBody = '{
  "contract_id": "string",
  "team_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);
});

<?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

{
  "contract_id": "string",
  "team_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

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

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())

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);
});

<?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	TimesheetSummary

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

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())

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);
});

<?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

{
  "company_id": "string",
  "weekday": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	CompanyWeeklyClosingDays

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: */*

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())

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);
});

<?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

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: */*

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())

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);
});

<?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

List fluida extensions

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/fluida_extensions \
  -H 'Accept: */*'

GET https://api.fluida.io/api/v1/fluida_extensions HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*'
}

r = requests.get('https://api.fluida.io/api/v1/fluida_extensions', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*'
};

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);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
);

$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{"*/*"},
    }

    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

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: */*

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())

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);
});

<?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

Contract

Creates a contract and invites it to the platform

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/contracts \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/contracts HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/contracts', headers = headers)

print(r.json())

const inputBody = '{
  "absence_self_approvement": false,
  "active": true,
  "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
  "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
  "clocking_duty": "always",
  "clocking_mode": "nfc",
  "company_email": "josiah.ondricka@swaniawski.com",
  "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
  "company_mobile": "07570 099283",
  "company_phone": "7145829592",
  "company_position": "Interactions",
  "company_switchboard": "669",
  "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
  "job_title": "Designer",
  "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
  "manual_clocking_approver_type": "self",
  "paghe_access_enabled": false,
  "register_id": "REGISTER_0",
  "remote_clocking_mode": "none",
  "remote_working_approvement": false,
  "remote_working_available": false,
  "role": "CompanyAdmin",
  "start_date": {
    "calendar": "Elixir.Calendar.ISO",
    "day": 17,
    "month": 2,
    "year": 2019
  },
  "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
  "team_ids": [
    "e49716ae-fe4e-44d0-968c-0f51950e884c",
    "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
  ],
  "type": "regular",
  "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
  "weekly_minutes": 2400,
  "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/contracts', 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/contracts");
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/contracts", data)
    req.Header = headers

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

POST /api/v1/contracts

Creates a contract and invites it to the platform

Body parameter

{
  "absence_self_approvement": false,
  "active": true,
  "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
  "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
  "clocking_duty": "always",
  "clocking_mode": "nfc",
  "company_email": "josiah.ondricka@swaniawski.com",
  "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
  "company_mobile": "07570 099283",
  "company_phone": "7145829592",
  "company_position": "Interactions",
  "company_switchboard": "669",
  "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
  "job_title": "Designer",
  "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
  "manual_clocking_approver_type": "self",
  "paghe_access_enabled": false,
  "register_id": "REGISTER_0",
  "remote_clocking_mode": "none",
  "remote_working_approvement": false,
  "remote_working_available": false,
  "role": "CompanyAdmin",
  "start_date": {
    "calendar": "Elixir.Calendar.ISO",
    "day": 17,
    "month": 2,
    "year": 2019
  },
  "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
  "team_ids": [
    "e49716ae-fe4e-44d0-968c-0f51950e884c",
    "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
  ],
  "type": "regular",
  "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
  "weekly_minutes": 2400,
  "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
}

Parameters

Name	In	Type	Required	Description
body	body	Contract	false	contract attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a list contract entries for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contracts/company/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contracts/company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contracts/company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/company/{company_id}',
{
  method: 'GET',

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

<?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/contracts/company/{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/contracts/company/{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/contracts/company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/contracts/company/{company_id}

Renders a list contract entries for a given company id...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
register_id	query	string	false	register id
subsidiary_id	query	string	false	subsidiary id
team_id	query	string	false	team id
active	query	boolean	false	if present, select only active contracts

Example responses

200 Response

[
  {
    "absence_self_approvement": false,
    "active": true,
    "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
    "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
    "clocking_duty": "always",
    "clocking_mode": "nfc",
    "company_email": "josiah.ondricka@swaniawski.com",
    "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
    "company_mobile": "07570 099283",
    "company_phone": "7145829592",
    "company_position": "Interactions",
    "company_switchboard": "669",
    "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
    "job_title": "Designer",
    "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
    "manual_clocking_approver_type": "self",
    "paghe_access_enabled": false,
    "register_id": "REGISTER_0",
    "remote_clocking_mode": "none",
    "remote_working_approvement": false,
    "remote_working_available": false,
    "role": "CompanyAdmin",
    "start_date": {
      "calendar": "Elixir.Calendar.ISO",
      "day": 17,
      "month": 2,
      "year": 2019
    },
    "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
    "team_ids": [
      "e49716ae-fe4e-44d0-968c-0f51950e884c",
      "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
    ],
    "type": "regular",
    "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
    "weekly_minutes": 2400,
    "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Contracts

Renders the approver for a given contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contracts/company/{company_id}/approver_for_contract/{contract_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contracts/company/{company_id}/approver_for_contract/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contracts/company/{company_id}/approver_for_contract/{contract_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/company/{company_id}/approver_for_contract/{contract_id}',
{
  method: 'GET',

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

<?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/contracts/company/{company_id}/approver_for_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/contracts/company/{company_id}/approver_for_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/contracts/company/{company_id}/approver_for_contract/{contract_id}", data)
    req.Header = headers

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

GET /api/v1/contracts/company/{company_id}/approver_for_contract/{contract_id}

Renders the approver for a given contract id...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
contract_id	path	string	true	contract id

Example responses

200 Response

{
  "absence_self_approvement": false,
  "active": true,
  "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
  "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
  "clocking_duty": "always",
  "clocking_mode": "nfc",
  "company_email": "josiah.ondricka@swaniawski.com",
  "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
  "company_mobile": "07570 099283",
  "company_phone": "7145829592",
  "company_position": "Interactions",
  "company_switchboard": "669",
  "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
  "job_title": "Designer",
  "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
  "manual_clocking_approver_type": "self",
  "paghe_access_enabled": false,
  "register_id": "REGISTER_0",
  "remote_clocking_mode": "none",
  "remote_working_approvement": false,
  "remote_working_available": false,
  "role": "CompanyAdmin",
  "start_date": {
    "calendar": "Elixir.Calendar.ISO",
    "day": 17,
    "month": 2,
    "year": 2019
  },
  "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
  "team_ids": [
    "e49716ae-fe4e-44d0-968c-0f51950e884c",
    "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
  ],
  "type": "regular",
  "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
  "weekly_minutes": 2400,
  "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Contract

Renders a list of contract entries for a given approver id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contracts/company/{company_id}/contracts_by_approver/{approver_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contracts/company/{company_id}/contracts_by_approver/{approver_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contracts/company/{company_id}/contracts_by_approver/{approver_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/company/{company_id}/contracts_by_approver/{approver_id}',
{
  method: 'GET',

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

<?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/contracts/company/{company_id}/contracts_by_approver/{approver_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/contracts/company/{company_id}/contracts_by_approver/{approver_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/contracts/company/{company_id}/contracts_by_approver/{approver_id}", data)
    req.Header = headers

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

GET /api/v1/contracts/company/{company_id}/contracts_by_approver/{approver_id}

Renders a list of contract entries for a given approver id...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
approver_id	path	string	true	approver id
active_contracts	query	boolean	false	active contracts

Example responses

200 Response

[
  {
    "absence_self_approvement": false,
    "active": true,
    "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
    "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
    "clocking_duty": "always",
    "clocking_mode": "nfc",
    "company_email": "josiah.ondricka@swaniawski.com",
    "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
    "company_mobile": "07570 099283",
    "company_phone": "7145829592",
    "company_position": "Interactions",
    "company_switchboard": "669",
    "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
    "job_title": "Designer",
    "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
    "manual_clocking_approver_type": "self",
    "paghe_access_enabled": false,
    "register_id": "REGISTER_0",
    "remote_clocking_mode": "none",
    "remote_working_approvement": false,
    "remote_working_available": false,
    "role": "CompanyAdmin",
    "start_date": {
      "calendar": "Elixir.Calendar.ISO",
      "day": 17,
      "month": 2,
      "year": 2019
    },
    "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
    "team_ids": [
      "e49716ae-fe4e-44d0-968c-0f51950e884c",
      "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
    ],
    "type": "regular",
    "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
    "weekly_minutes": 2400,
    "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Contracts

List Contracts Paginated

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contracts/company/{company_id}/paginated \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contracts/company/{company_id}/paginated HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contracts/company/{company_id}/paginated', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/company/{company_id}/paginated',
{
  method: 'GET',

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

<?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/contracts/company/{company_id}/paginated', 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/contracts/company/{company_id}/paginated");
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/contracts/company/{company_id}/paginated", data)
    req.Header = headers

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

GET /api/v1/contracts/company/{company_id}/paginated

Renders a list contract entries for a given company id paginated

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
subsidiary_ids	query	array[string]	false	subsidiary ids
team_ids	query	array[string]	false	team ids
active	query	boolean	false	if present, select only active contracts
page	query	integer	false	requested page
page_size	query	integer	false	page size

Example responses

200 Response

{
  "entries": [
    {
      "absence_self_approvement": false,
      "active": true,
      "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
      "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
      "clocking_duty": "always",
      "clocking_mode": "nfc",
      "company_email": "josiah.ondricka@swaniawski.com",
      "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
      "company_mobile": "07570 099283",
      "company_phone": "7145829592",
      "company_position": "Interactions",
      "company_switchboard": "669",
      "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
      "job_title": "Designer",
      "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
      "manual_clocking_approver_type": "self",
      "paghe_access_enabled": false,
      "register_id": "REGISTER_0",
      "remote_clocking_mode": "none",
      "remote_working_approvement": false,
      "remote_working_available": false,
      "role": "CompanyAdmin",
      "start_date": {
        "calendar": "Elixir.Calendar.ISO",
        "day": 17,
        "month": 2,
        "year": 2019
      },
      "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
      "team_ids": [
        "e49716ae-fe4e-44d0-968c-0f51950e884c",
        "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
      ],
      "type": "regular",
      "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
      "weekly_minutes": 2400,
      "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
    }
  ],
  "page_number": 0,
  "page_size": 0,
  "total_entries": 0,
  "total_pages": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractsPage

Renders a list of readable contract entries for a given contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contracts/company/{company_id}/readable_contracts/{contract_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contracts/company/{company_id}/readable_contracts/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contracts/company/{company_id}/readable_contracts/{contract_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/company/{company_id}/readable_contracts/{contract_id}',
{
  method: 'GET',

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

<?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/contracts/company/{company_id}/readable_contracts/{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/contracts/company/{company_id}/readable_contracts/{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/contracts/company/{company_id}/readable_contracts/{contract_id}", data)
    req.Header = headers

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

GET /api/v1/contracts/company/{company_id}/readable_contracts/{contract_id}

Renders a list of readable contract entries for a given contract id

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
contract_id	path	string	true	contract_id id

Example responses

200 Response

[
  {
    "absence_self_approvement": false,
    "active": true,
    "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
    "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
    "clocking_duty": "always",
    "clocking_mode": "nfc",
    "company_email": "josiah.ondricka@swaniawski.com",
    "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
    "company_mobile": "07570 099283",
    "company_phone": "7145829592",
    "company_position": "Interactions",
    "company_switchboard": "669",
    "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
    "job_title": "Designer",
    "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
    "manual_clocking_approver_type": "self",
    "paghe_access_enabled": false,
    "register_id": "REGISTER_0",
    "remote_clocking_mode": "none",
    "remote_working_approvement": false,
    "remote_working_available": false,
    "role": "CompanyAdmin",
    "start_date": {
      "calendar": "Elixir.Calendar.ISO",
      "day": 17,
      "month": 2,
      "year": 2019
    },
    "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
    "team_ids": [
      "e49716ae-fe4e-44d0-968c-0f51950e884c",
      "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
    ],
    "type": "regular",
    "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
    "weekly_minutes": 2400,
    "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Contracts

Deletes chosen contract

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/contracts/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/contracts/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/contracts/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{id}',
{
  method: 'DELETE',

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

<?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/contracts/{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/contracts/{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/contracts/{id}", data)
    req.Header = headers

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

DELETE /api/v1/contracts/{id}

Deletes chosen contract...

Parameters

Name	In	Type	Required	Description
id	path	string	true	subsidiary id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
200	OK	Ok	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a a contract for a given id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/contracts/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/contracts/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/contracts/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{id}',
{
  method: 'GET',

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

<?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/contracts/{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/contracts/{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/contracts/{id}", data)
    req.Header = headers

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

GET /api/v1/contracts/{id}

Renders a a contract for a given id...

Parameters

Name	In	Type	Required	Description
id	path	string	true	contract id

Example responses

200 Response

{
  "absence_self_approvement": false,
  "active": true,
  "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
  "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
  "clocking_duty": "always",
  "clocking_mode": "nfc",
  "company_email": "josiah.ondricka@swaniawski.com",
  "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
  "company_mobile": "07570 099283",
  "company_phone": "7145829592",
  "company_position": "Interactions",
  "company_switchboard": "669",
  "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
  "job_title": "Designer",
  "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
  "manual_clocking_approver_type": "self",
  "paghe_access_enabled": false,
  "register_id": "REGISTER_0",
  "remote_clocking_mode": "none",
  "remote_working_approvement": false,
  "remote_working_available": false,
  "role": "CompanyAdmin",
  "start_date": {
    "calendar": "Elixir.Calendar.ISO",
    "day": 17,
    "month": 2,
    "year": 2019
  },
  "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
  "team_ids": [
    "e49716ae-fe4e-44d0-968c-0f51950e884c",
    "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
  ],
  "type": "regular",
  "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
  "weekly_minutes": 2400,
  "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Contract

Updates chosen contract

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/contracts/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/contracts/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/contracts/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "absence_self_approvement": false,
  "active": true,
  "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
  "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
  "clocking_duty": "always",
  "clocking_mode": "nfc",
  "company_email": "josiah.ondricka@swaniawski.com",
  "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
  "company_mobile": "07570 099283",
  "company_phone": "7145829592",
  "company_position": "Interactions",
  "company_switchboard": "669",
  "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
  "job_title": "Designer",
  "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
  "manual_clocking_approver_type": "self",
  "paghe_access_enabled": false,
  "register_id": "REGISTER_0",
  "remote_clocking_mode": "none",
  "remote_working_approvement": false,
  "remote_working_available": false,
  "role": "CompanyAdmin",
  "start_date": {
    "calendar": "Elixir.Calendar.ISO",
    "day": 17,
    "month": 2,
    "year": 2019
  },
  "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
  "team_ids": [
    "e49716ae-fe4e-44d0-968c-0f51950e884c",
    "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
  ],
  "type": "regular",
  "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
  "weekly_minutes": 2400,
  "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/contracts/{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/contracts/{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/contracts/{id}", data)
    req.Header = headers

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

PUT /api/v1/contracts/{id}

Updates chosen contract...

Body parameter

{
  "absence_self_approvement": false,
  "active": true,
  "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
  "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
  "clocking_duty": "always",
  "clocking_mode": "nfc",
  "company_email": "josiah.ondricka@swaniawski.com",
  "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
  "company_mobile": "07570 099283",
  "company_phone": "7145829592",
  "company_position": "Interactions",
  "company_switchboard": "669",
  "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
  "job_title": "Designer",
  "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
  "manual_clocking_approver_type": "self",
  "paghe_access_enabled": false,
  "register_id": "REGISTER_0",
  "remote_clocking_mode": "none",
  "remote_working_approvement": false,
  "remote_working_available": false,
  "role": "CompanyAdmin",
  "start_date": {
    "calendar": "Elixir.Calendar.ISO",
    "day": 17,
    "month": 2,
    "year": 2019
  },
  "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
  "team_ids": [
    "e49716ae-fe4e-44d0-968c-0f51950e884c",
    "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
  ],
  "type": "regular",
  "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
  "weekly_minutes": 2400,
  "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	contract id
body	body	Contract	false	contract attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
200	OK	Ok	None
401	Unauthorized	Unauthorized	Unauthorized

Updates chosen contract badge

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/contracts/{id}/badge \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/contracts/{id}/badge HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/contracts/{id}/badge', headers = headers)

print(r.json())

const inputBody = '{
  "absence_self_approvement": false,
  "active": true,
  "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
  "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
  "clocking_duty": "always",
  "clocking_mode": "nfc",
  "company_email": "josiah.ondricka@swaniawski.com",
  "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
  "company_mobile": "07570 099283",
  "company_phone": "7145829592",
  "company_position": "Interactions",
  "company_switchboard": "669",
  "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
  "job_title": "Designer",
  "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
  "manual_clocking_approver_type": "self",
  "paghe_access_enabled": false,
  "register_id": "REGISTER_0",
  "remote_clocking_mode": "none",
  "remote_working_approvement": false,
  "remote_working_available": false,
  "role": "CompanyAdmin",
  "start_date": {
    "calendar": "Elixir.Calendar.ISO",
    "day": 17,
    "month": 2,
    "year": 2019
  },
  "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
  "team_ids": [
    "e49716ae-fe4e-44d0-968c-0f51950e884c",
    "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
  ],
  "type": "regular",
  "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
  "weekly_minutes": 2400,
  "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{id}/badge',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/contracts/{id}/badge', 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/contracts/{id}/badge");
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/contracts/{id}/badge", data)
    req.Header = headers

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

PUT /api/v1/contracts/{id}/badge

Updates chosen contract badge...

Body parameter

{
  "absence_self_approvement": false,
  "active": true,
  "approver_id": "ed14d39f-30d5-449c-a389-90b9cc32fdfa",
  "badge_id": "436485d4-06e5-4261-a4f3-ae2be9c2e0fc",
  "clocking_duty": "always",
  "clocking_mode": "nfc",
  "company_email": "josiah.ondricka@swaniawski.com",
  "company_id": "900c6564-d4ad-4dc3-b3cb-1a3c916c56d4",
  "company_mobile": "07570 099283",
  "company_phone": "7145829592",
  "company_position": "Interactions",
  "company_switchboard": "669",
  "id": "69095b05-477e-4ab9-9b1e-468d475ccf68",
  "job_title": "Designer",
  "main_team_id": "d994e327-19a9-4c75-aa50-1f2f9f4e9d88",
  "manual_clocking_approver_type": "self",
  "paghe_access_enabled": false,
  "register_id": "REGISTER_0",
  "remote_clocking_mode": "none",
  "remote_working_approvement": false,
  "remote_working_available": false,
  "role": "CompanyAdmin",
  "start_date": {
    "calendar": "Elixir.Calendar.ISO",
    "day": 17,
    "month": 2,
    "year": 2019
  },
  "subsidiary_id": "8aec43ba-2a0a-44d6-8536-b93ceecb2adc",
  "team_ids": [
    "e49716ae-fe4e-44d0-968c-0f51950e884c",
    "b602a0ca-83ea-4d7b-8e54-a72f2d4f520a"
  ],
  "type": "regular",
  "user_id": "3ade1e03-0ba6-4ea8-bf3c-58c0b6fb1c63",
  "weekly_minutes": 2400,
  "weekly_schedule_id": "d475667b-e714-4d55-aa7c-89a6e0adef35"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	contract id
body	body	Contract	false	contract attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Updates contract feature configs

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/contracts/{id}/features \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/contracts/{id}/features HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/contracts/{id}/features', headers = headers)

print(r.json())

const inputBody = '{
  "configs": {
    "preferences": {
      "extraordinary": true
    }
  },
  "feature_code": "extraordinary"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{id}/features',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/contracts/{id}/features', 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/contracts/{id}/features");
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/contracts/{id}/features", data)
    req.Header = headers

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

PUT /api/v1/contracts/{id}/features

Updates contract feature configs...

Body parameter

{
  "configs": {
    "preferences": {
      "extraordinary": true
    }
  },
  "feature_code": "extraordinary"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	contract id
body	body	ContractFeatureParams	false	feature config attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Restores a deleted contract

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/contracts/{id}/restore \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/contracts/{id}/restore HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/contracts/{id}/restore', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{id}/restore',
{
  method: 'PUT',

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

<?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/contracts/{id}/restore', 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/contracts/{id}/restore");
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/contracts/{id}/restore", data)
    req.Header = headers

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

PUT /api/v1/contracts/{id}/restore

Restores a deleted contract...

Parameters

Name	In	Type	Required	Description
id	path	string	true	contract id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Creates contract daily schedule override

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/contracts/{id}/schedule/daily \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/contracts/{id}/schedule/daily HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/contracts/{id}/schedule/daily', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "98a763df-53b3-43bf-a687-2f55a6fc0bed",
  "computed_name": "1h 40m",
  "id": "471e6d66-2f53-45b9-8f30-654f873bedcc",
  "name": "Turno Standard",
  "note": "note",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "shift_code_name": "MT"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{id}/schedule/daily',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/contracts/{id}/schedule/daily', 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/contracts/{id}/schedule/daily");
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/contracts/{id}/schedule/daily", data)
    req.Header = headers

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

POST /api/v1/contracts/{id}/schedule/daily

Creates contract daily schedule override...

Body parameter

{
  "company_id": "98a763df-53b3-43bf-a687-2f55a6fc0bed",
  "computed_name": "1h 40m",
  "id": "471e6d66-2f53-45b9-8f30-654f873bedcc",
  "name": "Turno Standard",
  "note": "note",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "shift_code_name": "MT"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	contract id
body	body	DailySchedule	false	schedule attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Creates contract weekly schedule override

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/contracts/{id}/schedule/weekly \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/contracts/{id}/schedule/weekly HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/contracts/{id}/schedule/weekly', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "8955a123-b10d-4a6b-9c2d-90de8486dd10",
  "fri": "726ee840-f36a-4128-aa65-f93f9484d455",
  "id": "bce1dea1-17a9-489f-875e-6ab5ee76ebcc",
  "mon": "a28b417a-8732-4c21-94ad-e6cf49ef0efd",
  "name": "Settimana Standard",
  "note": "note",
  "thu": "8389b99e-b0d2-4d84-8643-e1b484fdc3f8",
  "tue": "6de10b32-4a54-427b-b0d0-9efaea64f7ca",
  "wed": "9386582a-301e-4866-9455-c7c95b399f21",
  "weekly_minutes": 2400
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/contracts/{id}/schedule/weekly',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/contracts/{id}/schedule/weekly', 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/contracts/{id}/schedule/weekly");
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/contracts/{id}/schedule/weekly", data)
    req.Header = headers

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

POST /api/v1/contracts/{id}/schedule/weekly

Creates contract weekly schedule override...

Body parameter

{
  "company_id": "8955a123-b10d-4a6b-9c2d-90de8486dd10",
  "fri": "726ee840-f36a-4128-aa65-f93f9484d455",
  "id": "bce1dea1-17a9-489f-875e-6ab5ee76ebcc",
  "mon": "a28b417a-8732-4c21-94ad-e6cf49ef0efd",
  "name": "Settimana Standard",
  "note": "note",
  "thu": "8389b99e-b0d2-4d84-8643-e1b484fdc3f8",
  "tue": "6de10b32-4a54-427b-b0d0-9efaea64f7ca",
  "wed": "9386582a-301e-4866-9455-c7c95b399f21",
  "weekly_minutes": 2400
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	contract id
body	body	WeeklySchedule	false	schedule attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

ExpenseReport

Creates an expense report

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/expense_reports \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/expense_reports HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/expense_reports', headers = headers)

print(r.json())

const inputBody = '{
  "change_log": [
    {}
  ],
  "company_id": "string",
  "contract_id": "string",
  "expenses_count": 0,
  "from": "string",
  "name": "string",
  "notes": "string",
  "refundable_amount": 0,
  "refunded_amount": 0,
  "refunded_at": "2019-08-24",
  "status": "string",
  "to": "string",
  "total_amount": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports', 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/expense_reports");
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/expense_reports", data)
    req.Header = headers

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

POST /api/v1/expense_reports

Creates an expense report

Body parameter

{
  "change_log": [
    {}
  ],
  "company_id": "string",
  "contract_id": "string",
  "expenses_count": 0,
  "from": "string",
  "name": "string",
  "notes": "string",
  "refundable_amount": 0,
  "refunded_amount": 0,
  "refunded_at": "2019-08-24",
  "status": "string",
  "to": "string",
  "total_amount": 0
}

Parameters

Name	In	Type	Required	Description
body	body	ExpenseReport	false	Expense Report attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Renders a list of Expense Reports by Company ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/by_company_id/{company_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/by_company_id/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/by_company_id/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/by_company_id/{company_id}',
{
  method: 'GET',

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

<?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/expense_reports/by_company_id/{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/expense_reports/by_company_id/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/expense_reports/by_company_id/{company_id}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/by_company_id/{company_id}

Renders a list of Expense Reports by Company ID

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Compny ID
from_date	query	string(date)	false	From date
to_date	query	string(date)	false	To date
updated_at_from	query	string(datetime)	false	Updated at from
updated_at_to	query	string(datetime)	false	Updated at to
limit	query	integer	false	Limit results number
status	query	array[string]	false	Status

Enumerated Values

Parameter	Value
status	pending
status	cancelled
status	accepted
status	rejected
status	refunded

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ExpenseReports
401	Unauthorized	Unauthorized	Unauthorized

List Expense Reports by Contract ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/by_contract_id/{contract_id}?from_date=2019-08-24&to_date=2019-08-24 \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/by_contract_id/{contract_id}?from_date=2019-08-24&to_date=2019-08-24 HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/by_contract_id/{contract_id}', params={
  'from_date': '2019-08-24',  'to_date': '2019-08-24'
}, headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/by_contract_id/{contract_id}?from_date=2019-08-24&to_date=2019-08-24',
{
  method: 'GET',

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

<?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/expense_reports/by_contract_id/{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/expense_reports/by_contract_id/{contract_id}?from_date=2019-08-24&to_date=2019-08-24");
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/expense_reports/by_contract_id/{contract_id}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/by_contract_id/{contract_id}

Renders a list of Expense Reports by Contract ID

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	Contract ID
from_date	query	string(date)	true	From Date
to_date	query	string(date)	true	To Date
limit	query	integer	false	Limit results number
status	query	array[string]	false	Status

Enumerated Values

Parameter	Value
status	pending
status	cancelled
status	accepted
status	rejected
status	refunded

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ExpenseReports
401	Unauthorized	Unauthorized	Unauthorized

List Expense Policies

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies',
{
  method: 'GET',

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

<?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/expense_reports/companies/{company_id}/expense_policies', 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/expense_reports/companies/{company_id}/expense_policies");
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/expense_reports/companies/{company_id}/expense_policies", data)
    req.Header = headers

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

GET /api/v1/expense_reports/companies/{company_id}/expense_policies

List Expense Policy by company id

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	ExpensePolicies
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Create Expense Policy

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies', headers = headers)

print(r.json())

const inputBody = '{
  "name": "string",
  "rules": [
    {
      "expense_type_code": "string",
      "expense_type_id": "string",
      "max_refundable_amount": 0
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports/companies/{company_id}/expense_policies', 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/expense_reports/companies/{company_id}/expense_policies");
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/expense_reports/companies/{company_id}/expense_policies", data)
    req.Header = headers

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

POST /api/v1/expense_reports/companies/{company_id}/expense_policies

Create Expense Policy

Body parameter

{
  "name": "string",
  "rules": [
    {
      "expense_type_code": "string",
      "expense_type_id": "string",
      "max_refundable_amount": 0
    }
  ]
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company Id
body	body	ExpensePolicyParams	true	ExpensePolicy attributes

Example responses

201 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	ExpensePolicy
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Get Expense Policy

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies/{id}',
{
  method: 'GET',

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

<?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/expense_reports/companies/{company_id}/expense_policies/{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/expense_reports/companies/{company_id}/expense_policies/{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/expense_reports/companies/{company_id}/expense_policies/{id}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/companies/{company_id}/expense_policies/{id}

Get Expense Policy by Id

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company Id
id	path	string	true	Id

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ExpensePolicy
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Update Expense Policy

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "name": "string",
  "rules": [
    {
      "expense_type_code": "string",
      "expense_type_id": "string",
      "max_refundable_amount": 0
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/companies/{company_id}/expense_policies/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports/companies/{company_id}/expense_policies/{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/expense_reports/companies/{company_id}/expense_policies/{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/expense_reports/companies/{company_id}/expense_policies/{id}", data)
    req.Header = headers

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

PUT /api/v1/expense_reports/companies/{company_id}/expense_policies/{id}

Update Expense Policy

Body parameter

{
  "name": "string",
  "rules": [
    {
      "expense_type_code": "string",
      "expense_type_id": "string",
      "max_refundable_amount": 0
    }
  ]
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company Id
id	path	string	true	Id
body	body	ExpensePolicyParams	true	ExpensePolicy attributes

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ExpensePolicy
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Renders a list of Expense Types

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/expense_types \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/expense_types HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/expense_types', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expense_types',
{
  method: 'GET',

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

<?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/expense_reports/expense_types', 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/expense_reports/expense_types");
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/expense_reports/expense_types", data)
    req.Header = headers

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

GET /api/v1/expense_reports/expense_types

Renders a list of Expense Types

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ExpenseTypes
401	Unauthorized	Unauthorized	Unauthorized

Creates an expense type

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/expense_reports/expense_types \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/expense_reports/expense_types HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/expense_reports/expense_types', headers = headers)

print(r.json())

const inputBody = '{
  "invite": {
    "category": "transports",
    "code": "train",
    "name": "EXPENSE_REPORT.TRAIN"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expense_types',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports/expense_types', 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/expense_reports/expense_types");
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/expense_reports/expense_types", data)
    req.Header = headers

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

POST /api/v1/expense_reports/expense_types

Creates an expense type

Body parameter

{
  "invite": {
    "category": "transports",
    "code": "train",
    "name": "EXPENSE_REPORT.TRAIN"
  }
}

Parameters

Name	In	Type	Required	Description
body	body	ExpenseType	false	ExpenseType attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Creates an expense

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/expense_reports/expenses \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/expense_reports/expenses HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/expense_reports/expenses', headers = headers)

print(r.json())

const inputBody = '{
  "accepted": true,
  "attachment_id": "string",
  "company_id": "string",
  "contract_id": "string",
  "expense_report_id": "string",
  "expense_type_id": "string",
  "from_location": {},
  "kilometers": 0,
  "km_cost": 0,
  "notes": "string",
  "payment_date": "string",
  "payment_type": "string",
  "project_billable": "string",
  "project_customer_id": "string",
  "project_id": "string",
  "refundable_amount": 0,
  "roundtrip": true,
  "title": "string",
  "to_location": {},
  "total_amount": 0,
  "user_car_id": "string",
  "user_car_model": "string",
  "user_car_plate_number": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports/expenses', 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/expense_reports/expenses");
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/expense_reports/expenses", data)
    req.Header = headers

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

POST /api/v1/expense_reports/expenses

Creates an expense

Body parameter

{
  "accepted": true,
  "attachment_id": "string",
  "company_id": "string",
  "contract_id": "string",
  "expense_report_id": "string",
  "expense_type_id": "string",
  "from_location": {},
  "kilometers": 0,
  "km_cost": 0,
  "notes": "string",
  "payment_date": "string",
  "payment_type": "string",
  "project_billable": "string",
  "project_customer_id": "string",
  "project_id": "string",
  "refundable_amount": 0,
  "roundtrip": true,
  "title": "string",
  "to_location": {},
  "total_amount": 0,
  "user_car_id": "string",
  "user_car_model": "string",
  "user_car_plate_number": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	Expense	false	Expense attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Renders a list of ExpensesCalendar by Contract ID and Date

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/expenses/by_calendar/{contract_id}/{date} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/expenses/by_calendar/{contract_id}/{date} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/expenses/by_calendar/{contract_id}/{date}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses/by_calendar/{contract_id}/{date}',
{
  method: 'GET',

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

<?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/expense_reports/expenses/by_calendar/{contract_id}/{date}', 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/expense_reports/expenses/by_calendar/{contract_id}/{date}");
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/expense_reports/expenses/by_calendar/{contract_id}/{date}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/expenses/by_calendar/{contract_id}/{date}

Renders a list of ExpensesCalendar by Contract ID and Date

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	Contract ID
date	path	string(date)	true	Date

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ExpensesCalendar
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of Expenses by Company ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/expenses/by_company_id/{company_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/expenses/by_company_id/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/expenses/by_company_id/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses/by_company_id/{company_id}',
{
  method: 'GET',

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

<?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/expense_reports/expenses/by_company_id/{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/expense_reports/expenses/by_company_id/{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{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/expense_reports/expenses/by_company_id/{company_id}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/expenses/by_company_id/{company_id}

Renders a list of Expenses by Company ID

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	Expenses
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of Expenses by Contract ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/expenses/by_contract_id/{contract_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/expenses/by_contract_id/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/expenses/by_contract_id/{contract_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses/by_contract_id/{contract_id}',
{
  method: 'GET',

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

<?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/expense_reports/expenses/by_contract_id/{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/expense_reports/expenses/by_contract_id/{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/expense_reports/expenses/by_contract_id/{contract_id}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/expenses/by_contract_id/{contract_id}

Renders a list of Expenses by Contract ID

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	Contract ID

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	Expenses
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of Expenses by Expense Report ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/expenses/by_report_id/{expense_report_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/expenses/by_report_id/{expense_report_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/expenses/by_report_id/{expense_report_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses/by_report_id/{expense_report_id}',
{
  method: 'GET',

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

<?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/expense_reports/expenses/by_report_id/{expense_report_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/expense_reports/expenses/by_report_id/{expense_report_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/expense_reports/expenses/by_report_id/{expense_report_id}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/expenses/by_report_id/{expense_report_id}

Renders a list of Expenses by Expense Report ID

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	Expense Report ID

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	Expenses
401	Unauthorized	Unauthorized	Unauthorized

Upload and parse a receipt

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/expense_reports/expenses/upload_and_parse_receipt \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/expense_reports/expenses/upload_and_parse_receipt HTTP/1.1
Host: api.fluida.io
Content-Type: application/x-www-form-urlencoded
Accept: */*

import requests
headers = {
  'Content-Type': 'application/x-www-form-urlencoded',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/expense_reports/expenses/upload_and_parse_receipt', headers = headers)

print(r.json())

const inputBody = '{
  "document": "string"
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses/upload_and_parse_receipt',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/x-www-form-urlencoded',
    '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/expense_reports/expenses/upload_and_parse_receipt', 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/expense_reports/expenses/upload_and_parse_receipt");
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/x-www-form-urlencoded"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/expense_reports/expenses/upload_and_parse_receipt", data)
    req.Header = headers

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

POST /api/v1/expense_reports/expenses/upload_and_parse_receipt

Upload and parse a receipt or an invoice

Body parameter

document: string

Parameters

Name	In	Type	Required	Description
body	body	object	false	none
» document	body	string(binary)	false	Attachment File

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ParsedReceipt
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Deletes an expense

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}',
{
  method: 'DELETE',

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

<?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/expense_reports/expenses/{expense_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/expense_reports/expenses/{expense_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/expense_reports/expenses/{expense_id}", data)
    req.Header = headers

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

DELETE /api/v1/expense_reports/expenses/{expense_id}

Deletes an expense

Parameters

Name	In	Type	Required	Description
expense_id	path	string	true	Expense ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Get Expense by ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}',
{
  method: 'GET',

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

<?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/expense_reports/expenses/{expense_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/expense_reports/expenses/{expense_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/expense_reports/expenses/{expense_id}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/expenses/{expense_id}

Get Expense by ID

Parameters

Name	In	Type	Required	Description
expense_id	path	string	true	Expense ID

Example responses

200 Response

{
  "accepted": true,
  "attachment_id": "string",
  "company_id": "string",
  "contract_id": "string",
  "expense_report_id": "string",
  "expense_type_id": "string",
  "from_location": {},
  "kilometers": 0,
  "km_cost": 0,
  "notes": "string",
  "payment_date": "string",
  "payment_type": "string",
  "project_billable": "string",
  "project_customer_id": "string",
  "project_id": "string",
  "refundable_amount": 0,
  "roundtrip": true,
  "title": "string",
  "to_location": {},
  "total_amount": 0,
  "user_car_id": "string",
  "user_car_model": "string",
  "user_car_plate_number": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Expense
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Updates an expense

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}', headers = headers)

print(r.json())

const inputBody = '{
  "accepted": true,
  "attachment_id": "string",
  "company_id": "string",
  "contract_id": "string",
  "expense_report_id": "string",
  "expense_type_id": "string",
  "from_location": {},
  "kilometers": 0,
  "km_cost": 0,
  "notes": "string",
  "payment_date": "string",
  "payment_type": "string",
  "project_billable": "string",
  "project_customer_id": "string",
  "project_id": "string",
  "refundable_amount": 0,
  "roundtrip": true,
  "title": "string",
  "to_location": {},
  "total_amount": 0,
  "user_car_id": "string",
  "user_car_model": "string",
  "user_car_plate_number": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports/expenses/{expense_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/expense_reports/expenses/{expense_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/expense_reports/expenses/{expense_id}", data)
    req.Header = headers

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

PUT /api/v1/expense_reports/expenses/{expense_id}

Updates an expense

Body parameter

{
  "accepted": true,
  "attachment_id": "string",
  "company_id": "string",
  "contract_id": "string",
  "expense_report_id": "string",
  "expense_type_id": "string",
  "from_location": {},
  "kilometers": 0,
  "km_cost": 0,
  "notes": "string",
  "payment_date": "string",
  "payment_type": "string",
  "project_billable": "string",
  "project_customer_id": "string",
  "project_id": "string",
  "refundable_amount": 0,
  "roundtrip": true,
  "title": "string",
  "to_location": {},
  "total_amount": 0,
  "user_car_id": "string",
  "user_car_model": "string",
  "user_car_plate_number": "string"
}

Parameters

Name	In	Type	Required	Description
expense_id	path	string	true	Expense ID
body	body	Expense	false	Expense attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Download an attachment to a specific expense

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/attachment \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/attachment HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/attachment', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/attachment',
{
  method: 'GET',

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

<?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/expense_reports/expenses/{expense_id}/attachment', 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/expense_reports/expenses/{expense_id}/attachment");
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/expense_reports/expenses/{expense_id}/attachment", data)
    req.Header = headers

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

GET /api/v1/expense_reports/expenses/{expense_id}/attachment

Download an attachment to a specific expense

Parameters

Name	In	Type	Required	Description
expense_id	path	string	true	Expense ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
200	OK	file	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Add an attachment to a specific expense

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/attachment \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/attachment HTTP/1.1
Host: api.fluida.io
Content-Type: application/x-www-form-urlencoded
Accept: */*

import requests
headers = {
  'Content-Type': 'application/x-www-form-urlencoded',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/attachment', headers = headers)

print(r.json())

const inputBody = '{
  "document": "string"
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/attachment',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/x-www-form-urlencoded',
    '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/expense_reports/expenses/{expense_id}/attachment', 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/expense_reports/expenses/{expense_id}/attachment");
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/x-www-form-urlencoded"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/attachment", data)
    req.Header = headers

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

PUT /api/v1/expense_reports/expenses/{expense_id}/attachment

Add an attachment to a specific expense

Body parameter

document: string

Parameters

Name	In	Type	Required	Description
expense_id	path	string	true	Expense ID
body	body	object	false	none
» document	body	string(binary)	false	Attachment File

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Updates an expense refundable amount

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/refundable_amount \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/refundable_amount HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/refundable_amount', headers = headers)

print(r.json())

const inputBody = '{
  "accepted": true,
  "attachment_id": "string",
  "company_id": "string",
  "contract_id": "string",
  "expense_report_id": "string",
  "expense_type_id": "string",
  "from_location": {},
  "kilometers": 0,
  "km_cost": 0,
  "notes": "string",
  "payment_date": "string",
  "payment_type": "string",
  "project_billable": "string",
  "project_customer_id": "string",
  "project_id": "string",
  "refundable_amount": 0,
  "roundtrip": true,
  "title": "string",
  "to_location": {},
  "total_amount": 0,
  "user_car_id": "string",
  "user_car_model": "string",
  "user_car_plate_number": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/expenses/{expense_id}/refundable_amount',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports/expenses/{expense_id}/refundable_amount', 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/expense_reports/expenses/{expense_id}/refundable_amount");
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/expense_reports/expenses/{expense_id}/refundable_amount", data)
    req.Header = headers

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

PUT /api/v1/expense_reports/expenses/{expense_id}/refundable_amount

Updates an expense refundable amount

Body parameter

{
  "accepted": true,
  "attachment_id": "string",
  "company_id": "string",
  "contract_id": "string",
  "expense_report_id": "string",
  "expense_type_id": "string",
  "from_location": {},
  "kilometers": 0,
  "km_cost": 0,
  "notes": "string",
  "payment_date": "string",
  "payment_type": "string",
  "project_billable": "string",
  "project_customer_id": "string",
  "project_id": "string",
  "refundable_amount": 0,
  "roundtrip": true,
  "title": "string",
  "to_location": {},
  "total_amount": 0,
  "user_car_id": "string",
  "user_car_model": "string",
  "user_car_plate_number": "string"
}

Parameters

Name	In	Type	Required	Description
expense_id	path	string	true	Expense ID
body	body	Expense	false	Expense attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Renders a list of cars by User ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/user_cars/by_user_id/{user_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/user_cars/by_user_id/{user_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/user_cars/by_user_id/{user_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/user_cars/by_user_id/{user_id}',
{
  method: 'GET',

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

<?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/expense_reports/user_cars/by_user_id/{user_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/expense_reports/user_cars/by_user_id/{user_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/expense_reports/user_cars/by_user_id/{user_id}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/user_cars/by_user_id/{user_id}

Renders a list of cars by User ID...

Parameters

Name	In	Type	Required	Description
user_id	path	string	true	User ID

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	UserCars
401	Unauthorized	Unauthorized	Unauthorized

Creates an user car

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}', headers = headers)

print(r.json())

const inputBody = '{
  "attachment_ids": [
    "string"
  ],
  "brand": "string",
  "change_log": [
    {}
  ],
  "km_cost": 0,
  "model": "string",
  "plate_number": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports/user_cars/{user_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/expense_reports/user_cars/{user_id}");
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/expense_reports/user_cars/{user_id}", data)
    req.Header = headers

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

POST /api/v1/expense_reports/user_cars/{user_id}

Creates an user car

Body parameter

{
  "attachment_ids": [
    "string"
  ],
  "brand": "string",
  "change_log": [
    {}
  ],
  "km_cost": 0,
  "model": "string",
  "plate_number": "string"
}

Parameters

Name	In	Type	Required	Description
user_id	path	string	true	User ID
body	body	UserCar	true	UserCar attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Renders a UserCar by plate number

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/plate_number/{plate_number} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/plate_number/{plate_number} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/plate_number/{plate_number}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/plate_number/{plate_number}',
{
  method: 'GET',

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

<?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/expense_reports/user_cars/{user_id}/plate_number/{plate_number}', 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/expense_reports/user_cars/{user_id}/plate_number/{plate_number}");
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/expense_reports/user_cars/{user_id}/plate_number/{plate_number}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/user_cars/{user_id}/plate_number/{plate_number}

Renders a UserCar by plate number...

Parameters

Name	In	Type	Required	Description
user_id	path	string	true	User ID
plate_number	path	string	true	PlateNumber

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	UserCar
401	Unauthorized	Unauthorized	Unauthorized

Deletes an user car

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}',
{
  method: 'DELETE',

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

<?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/expense_reports/user_cars/{user_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/expense_reports/user_cars/{user_id}/{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/expense_reports/user_cars/{user_id}/{id}", data)
    req.Header = headers

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

DELETE /api/v1/expense_reports/user_cars/{user_id}/{id}

Deletes an user car

Parameters

Name	In	Type	Required	Description
id	path	string	true	UserCar ID
user_id	path	string	true	User ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Renders a UserCar by ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}',
{
  method: 'GET',

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

<?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/expense_reports/user_cars/{user_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/expense_reports/user_cars/{user_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/expense_reports/user_cars/{user_id}/{id}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/user_cars/{user_id}/{id}

Renders a UserCar by ID...

Parameters

Name	In	Type	Required	Description
id	path	string	true	UserCar ID
user_id	path	string	true	User ID

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	UserCar
401	Unauthorized	Unauthorized	Unauthorized

Updates an user car

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "attachment_ids": [
    "string"
  ],
  "brand": "string",
  "change_log": [
    {}
  ],
  "km_cost": 0,
  "model": "string",
  "plate_number": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports/user_cars/{user_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/expense_reports/user_cars/{user_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/expense_reports/user_cars/{user_id}/{id}", data)
    req.Header = headers

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

PUT /api/v1/expense_reports/user_cars/{user_id}/{id}

Updates an user car

Body parameter

{
  "attachment_ids": [
    "string"
  ],
  "brand": "string",
  "change_log": [
    {}
  ],
  "km_cost": 0,
  "model": "string",
  "plate_number": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	UserCar ID
user_id	path	string	true	User ID
body	body	UserCar	true	UserCar attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

List attachments related to a car

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments',
{
  method: 'GET',

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

<?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/expense_reports/user_cars/{user_id}/{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/expense_reports/user_cars/{user_id}/{id}/attachments");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments", data)
    req.Header = headers

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

GET /api/v1/expense_reports/user_cars/{user_id}/{id}/attachments

List attachments related to a car...

Parameters

Name	In	Type	Required	Description
id	path	string	true	UserCar ID
user_id	path	string	true	User ID

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	UserCarAttachments
401	Unauthorized	Unauthorized	Unauthorized

Add an attachment to a specific car

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments HTTP/1.1
Host: api.fluida.io
Content-Type: application/x-www-form-urlencoded
Accept: */*

import requests
headers = {
  'Content-Type': 'application/x-www-form-urlencoded',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments', headers = headers)

print(r.json())

const inputBody = '{
  "document": "string"
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/x-www-form-urlencoded',
    '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/expense_reports/user_cars/{user_id}/{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/expense_reports/user_cars/{user_id}/{id}/attachments");
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/x-www-form-urlencoded"},
        "Accept": []string{"*/*"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments", data)
    req.Header = headers

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

PUT /api/v1/expense_reports/user_cars/{user_id}/{id}/attachments

Add an attachment to a specific car...

Body parameter

document: string

Parameters

Name	In	Type	Required	Description
id	path	string	true	UserCar ID
user_id	path	string	true	User ID
body	body	object	true	none
» document	body	string(binary)	true	Attachment File

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Removes an attachment to a specific car

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id}',
{
  method: 'DELETE',

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

<?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/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_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/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_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/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id}", data)
    req.Header = headers

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

DELETE /api/v1/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id}

Removes an attachment to a specific car...

Parameters

Name	In	Type	Required	Description
id	path	string	true	UserCar ID
user_id	path	string	true	User ID
attachment_id	path	string	true	Attachment ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Download specified attachment related to a car

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id}',
{
  method: 'GET',

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

<?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/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_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/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_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/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/user_cars/{user_id}/{id}/attachments/{attachment_id}

Download specified attachment related to a car...

Parameters

Name	In	Type	Required	Description
id	path	string	true	UserCar ID
user_id	path	string	true	User ID
attachment_id	path	string	true	Attachment ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
200	OK	file	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Delete an Expense Report

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/expense_reports/{expense_report_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/expense_reports/{expense_report_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}',
{
  method: 'DELETE',

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

<?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('DELETE','https://api.fluida.io/api/v1/expense_reports/{expense_report_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/expense_reports/{expense_report_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{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("DELETE", "https://api.fluida.io/api/v1/expense_reports/{expense_report_id}", data)
    req.Header = headers

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

DELETE /api/v1/expense_reports/{expense_report_id}

Delete an Expense Report

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	Expense Report ID

Example responses

401 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Get Expense Report by ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/expense_reports/{expense_report_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/expense_reports/{expense_report_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}',
{
  method: 'GET',

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

<?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/expense_reports/{expense_report_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/expense_reports/{expense_report_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/expense_reports/{expense_report_id}", data)
    req.Header = headers

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

GET /api/v1/expense_reports/{expense_report_id}

Get Expense Report by ID

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	Expense Report ID

Example responses

200 Response

{
  "change_log": [
    {}
  ],
  "company_id": "string",
  "contract_id": "string",
  "expenses_count": 0,
  "from": "string",
  "name": "string",
  "notes": "string",
  "refundable_amount": 0,
  "refunded_amount": 0,
  "refunded_at": "2019-08-24",
  "status": "string",
  "to": "string",
  "total_amount": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ExpenseReport
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Updates an expense report

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/expense_reports/{expense_report_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/expense_reports/{expense_report_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "contract_id": "string",
  "id": "string",
  "name": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports/{expense_report_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/expense_reports/{expense_report_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/expense_reports/{expense_report_id}", data)
    req.Header = headers

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

PUT /api/v1/expense_reports/{expense_report_id}

Updates an expense report

Body parameter

{
  "company_id": "string",
  "contract_id": "string",
  "id": "string",
  "name": "string"
}

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	ExpenseReport ID
body	body	ExpenseReportBody	false	ExpenseReport attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Adds a set of Expenses to an Expense Report

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/add_to_report \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/add_to_report HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/add_to_report', headers = headers)

print(r.json())

const inputBody = '[
  "string"
]';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/add_to_report',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/expense_reports/{expense_report_id}/add_to_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/expense_reports/{expense_report_id}/add_to_report");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/add_to_report", data)
    req.Header = headers

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

POST /api/v1/expense_reports/{expense_report_id}/add_to_report

Adds a set of Expenses to an Expense Report

Body parameter

[
  "string"
]

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	Expense Report ID
body	body	UUIDsList	true	Expense IDs

Example responses

401 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Cancel an Expense Report

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel',
{
  method: 'POST',

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

<?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('POST','https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel', 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/expense_reports/{expense_report_id}/cancel");
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{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel", data)
    req.Header = headers

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

POST /api/v1/expense_reports/{expense_report_id}/cancel

Cancel an Expense Report

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	Expense Report ID

Example responses

401 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Cancel Expense Report Refund

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel_refund \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel_refund HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel_refund', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel_refund',
{
  method: 'PUT',

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

<?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('PUT','https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel_refund', 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/expense_reports/{expense_report_id}/cancel_refund");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/cancel_refund", data)
    req.Header = headers

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

PUT /api/v1/expense_reports/{expense_report_id}/cancel_refund

Cancel Expense Report Refund

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	Expense Report ID

Example responses

200 Response

{
  "change_log": [
    {}
  ],
  "company_id": "string",
  "contract_id": "string",
  "expenses_count": 0,
  "from": "string",
  "name": "string",
  "notes": "string",
  "refundable_amount": 0,
  "refunded_amount": 0,
  "refunded_at": "2019-08-24",
  "status": "string",
  "to": "string",
  "total_amount": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ExpenseReport
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Adds note to an ExpenseReport

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/notes \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/notes HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/notes', headers = headers)

print(r.json())

const inputBody = '{
  "expense_report": {
    "notes": "string"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/notes',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports/{expense_report_id}/notes', 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/expense_reports/{expense_report_id}/notes");
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/expense_reports/{expense_report_id}/notes", data)
    req.Header = headers

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

PUT /api/v1/expense_reports/{expense_report_id}/notes

Adds note to an ExpenseReport

Body parameter

{
  "expense_report": {
    "notes": "string"
  }
}

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	ExpenseReport ID
body	body	ExpenseReportNotesRequest	true	ExpenseReport attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Adds refund to an ExpenseReport

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/refund \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/refund HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/refund', headers = headers)

print(r.json())

const inputBody = '{
  "expense_report": {
    "refunded_amount": 0,
    "refunded_at": "2019-08-24"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/refund',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/expense_reports/{expense_report_id}/refund', 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/expense_reports/{expense_report_id}/refund");
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/expense_reports/{expense_report_id}/refund", data)
    req.Header = headers

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

PUT /api/v1/expense_reports/{expense_report_id}/refund

Adds refund to an ExpenseReport

Body parameter

{
  "expense_report": {
    "refunded_amount": 0,
    "refunded_at": "2019-08-24"
  }
}

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	ExpenseReport ID
body	body	ExpenseReportRefundRequest	true	ExpenseReport attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Removes a set of Expenses from an Expense Report

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/remove_from_report \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/remove_from_report HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/remove_from_report', headers = headers)

print(r.json())

const inputBody = '[
  "string"
]';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/remove_from_report',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/expense_reports/{expense_report_id}/remove_from_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/expense_reports/{expense_report_id}/remove_from_report");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/remove_from_report", data)
    req.Header = headers

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

POST /api/v1/expense_reports/{expense_report_id}/remove_from_report

Removes a set of Expense from an Expense Report

Body parameter

[
  "string"
]

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	Expense Report ID
body	body	UUIDsList	true	Expense IDs

Example responses

401 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Submit an Expense Report

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/submit \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/submit HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/submit', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/submit',
{
  method: 'POST',

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

<?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('POST','https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/submit', 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/expense_reports/{expense_report_id}/submit");
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{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/expense_reports/{expense_report_id}/submit", data)
    req.Header = headers

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

POST /api/v1/expense_reports/{expense_report_id}/submit

Submit an Expense Report

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	Expense Report ID

Example responses

401 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Delete an attachment to a specific expense

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/expense_reports/expenses/{expense_id}/attachment \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/expense_reports/expenses/{expense_id}/attachment HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/expense_reports/expenses/{expense_id}/attachment', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/expense_reports/expenses/{expense_id}/attachment',
{
  method: 'DELETE',

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

<?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/expense_reports/expenses/{expense_id}/attachment', 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/expense_reports/expenses/{expense_id}/attachment");
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/expense_reports/expenses/{expense_id}/attachment", data)
    req.Header = headers

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

DELETE /expense_reports/expenses/{expense_id}/attachment

Delete an attachment to a specific expense

Parameters

Name	In	Type	Required	Description
expense_id	path	string	true	Expense ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Export

Request an activity summary export by company

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/exports/activity_summary/{company_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/exports/activity_summary/{company_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/exports/activity_summary/{company_id}', headers = headers)

print(r.json())

const inputBody = '{
  "contract_id": "string",
  "decimal_format": true,
  "end_date": "string",
  "presences": true,
  "recipient_date_format": "string",
  "recipient_email": "string",
  "recipient_firstname": "string",
  "recipient_lastname": "string",
  "recipient_locale": "string",
  "send_email": true,
  "start_date": "string",
  "subsidiary_id": "string",
  "team_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/exports/activity_summary/{company_id}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/exports/activity_summary/{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/exports/activity_summary/{company_id}");
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/exports/activity_summary/{company_id}", data)
    req.Header = headers

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

POST /api/v1/exports/activity_summary/{company_id}

Request an activity summary export by company...

Body parameter

{
  "contract_id": "string",
  "decimal_format": true,
  "end_date": "string",
  "presences": true,
  "recipient_date_format": "string",
  "recipient_email": "string",
  "recipient_firstname": "string",
  "recipient_lastname": "string",
  "recipient_locale": "string",
  "send_email": true,
  "start_date": "string",
  "subsidiary_id": "string",
  "team_id": "string"
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company ID
body	body	AcitivtySummaryByCompanyExportRequest	false	Export request body

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	None
401	Unauthorized	Unauthorized	Unauthorized

Request an export for a given company

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/exports/companies/{company_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/exports/companies/{company_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/exports/companies/{company_id}', headers = headers)

print(r.json())

const inputBody = '{
  "async": false,
  "company_id": "dd32d678-426f-4524-aa77-3086a0d738e0",
  "export_type": "zucchetti",
  "month": "10",
  "year": "2023"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/exports/companies/{company_id}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/exports/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/exports/companies/{company_id}");
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/exports/companies/{company_id}", data)
    req.Header = headers

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

POST /api/v1/exports/companies/{company_id}

Request an export for a given company

Body parameter

{
  "async": false,
  "company_id": "dd32d678-426f-4524-aa77-3086a0d738e0",
  "export_type": "zucchetti",
  "month": "10",
  "year": "2023"
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company ID
body	body	Export	false	export request body

Example responses

400 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	None
202	Accepted	Accepted	None
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized

Request an expense_report export for a given company

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/exports/expense_report/by_company/{company_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/exports/expense_report/by_company/{company_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/exports/expense_report/by_company/{company_id}', headers = headers)

print(r.json())

const inputBody = '{
  "contract_id": "string",
  "end_date": "string",
  "recipient_date_format": "string",
  "recipient_email": "string",
  "recipient_firstname": "string",
  "recipient_lastname": "string",
  "recipient_locale": "string",
  "send_email": true,
  "start_date": "string",
  "status": "string",
  "subsidiary_id": "string",
  "team_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/exports/expense_report/by_company/{company_id}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/exports/expense_report/by_company/{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/exports/expense_report/by_company/{company_id}");
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/exports/expense_report/by_company/{company_id}", data)
    req.Header = headers

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

POST /api/v1/exports/expense_report/by_company/{company_id}

Request an expense_report export for a given company...

Body parameter

{
  "contract_id": "string",
  "end_date": "string",
  "recipient_date_format": "string",
  "recipient_email": "string",
  "recipient_firstname": "string",
  "recipient_lastname": "string",
  "recipient_locale": "string",
  "send_email": true,
  "start_date": "string",
  "status": "string",
  "subsidiary_id": "string",
  "team_id": "string"
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Expense Report ID
body	body	ExpensesByCompanyExportRequest	false	Export request body

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	None
401	Unauthorized	Unauthorized	Unauthorized

Request an export for a given expense_report

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/exports/expense_report/{expense_report_id}/{export_type} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/exports/expense_report/{expense_report_id}/{export_type} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/exports/expense_report/{expense_report_id}/{export_type}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/exports/expense_report/{expense_report_id}/{export_type}',
{
  method: 'POST',

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

<?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/exports/expense_report/{expense_report_id}/{export_type}', 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/exports/expense_report/{expense_report_id}/{export_type}");
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/exports/expense_report/{expense_report_id}/{export_type}", data)
    req.Header = headers

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

POST /api/v1/exports/expense_report/{expense_report_id}/{export_type}

Request an export for a given expense_report...

Parameters

Name	In	Type	Required	Description
expense_report_id	path	string	true	Expense Report ID
export_type	path	string	true	Export

Enumerated Values

Parameter	Value
export_type	pdf
export_type	xlsx

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
201	Created	Created	None
401	Unauthorized	Unauthorized	Unauthorized

Download an export for reseller monthly usage

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/exports/monthly_reseller_usage/{reseller_id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/exports/monthly_reseller_usage/{reseller_id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/exports/monthly_reseller_usage/{reseller_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/exports/monthly_reseller_usage/{reseller_id}',
{
  method: 'GET',

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

<?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/exports/monthly_reseller_usage/{reseller_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/exports/monthly_reseller_usage/{reseller_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/exports/monthly_reseller_usage/{reseller_id}", data)
    req.Header = headers

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

GET /api/v1/exports/monthly_reseller_usage/{reseller_id}

Download an export for reseller monthly usage...

Parameters

Name	In	Type	Required	Description
reseller_id	path	string	true	Reseller ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	None
401	Unauthorized	Unauthorized	Unauthorized

Download export

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/exports/{document_id}/download \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/exports/{document_id}/download HTTP/1.1
Host: api.fluida.io

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/exports/{document_id}/download', headers = headers)

print(r.json())

const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/exports/{document_id}/download',
{
  method: 'GET',

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

<?php

require 'vendor/autoload.php';

$headers = array(
    '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/exports/{document_id}/download', 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/exports/{document_id}/download");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/exports/{document_id}/download", data)
    req.Header = headers

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

GET /api/v1/exports/{document_id}/download

Download export...

Parameters

Name	In	Type	Required	Description
document_id	path	string	true	document id

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Invite

Import Invites

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/companies/{company_id}/invites/import \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/companies/{company_id}/invites/import HTTP/1.1
Host: api.fluida.io
Content-Type: application/x-www-form-urlencoded
Accept: */*

import requests
headers = {
  'Content-Type': 'application/x-www-form-urlencoded',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/companies/{company_id}/invites/import', headers = headers)

print(r.json())

const inputBody = '{
  "invite_file": "string"
}';
const headers = {
  'Content-Type':'application/x-www-form-urlencoded',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/invites/import',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/x-www-form-urlencoded',
    '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}/invites/import', 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}/invites/import");
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/x-www-form-urlencoded"},
        "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}/invites/import", data)
    req.Header = headers

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

POST /api/v1/companies/{company_id}/invites/import

Import invites from excel file

Body parameter

invite_file: string

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company Id
body	body	object	true	none
» invite_file	body	string(binary)	true	Excel File upload

Example responses

201 Response

Responses

Status	Meaning	Description	Schema
201	Created	Success	InviteImportStatus
401	Unauthorized	Unauthorized	Unauthorized

Deletes chosen invite

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/companies/{company_id}/invites/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/companies/{company_id}/invites/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/companies/{company_id}/invites/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/invites/{id}',
{
  method: 'DELETE',

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

<?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}/invites/{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}/invites/{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}/invites/{id}", data)
    req.Header = headers

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

DELETE /api/v1/companies/{company_id}/invites/{id}

Deletes chosen invite

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company id
id	path	string	true	Invite id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
200	OK	Ok	None
401	Unauthorized	Unauthorized	Unauthorized

Update an invite to company

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/companies/{company_id}/invites/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/companies/{company_id}/invites/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/companies/{company_id}/invites/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "invite": {
    "company_id": "95444f0d-d0b2-4478-a186-51a26b420733",
    "company_name": "Company name LTD",
    "email": "mario.rossi@example.com",
    "firstname": "Mario",
    "lastname": "Rossi",
    "main_team_id": "bd8c7f2a-7b8a-46c5-a389-2f04bea0fa5f",
    "role": "CompanyAdmin",
    "subsidiary_id": "18b97406-69da-4674-8152-5742734dd315",
    "subsidiary_name": "Subsidiary name",
    "team_ids": [
      "14c32c74-b361-4d12-a3da-b775c2f856dc"
    ],
    "type": "regular"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/companies/{company_id}/invites/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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}/invites/{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}/invites/{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}/invites/{id}", data)
    req.Header = headers

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

PUT /api/v1/companies/{company_id}/invites/{id}

Update an invite and send an email to the owner

Body parameter

{
  "invite": {
    "company_id": "95444f0d-d0b2-4478-a186-51a26b420733",
    "company_name": "Company name LTD",
    "email": "mario.rossi@example.com",
    "firstname": "Mario",
    "lastname": "Rossi",
    "main_team_id": "bd8c7f2a-7b8a-46c5-a389-2f04bea0fa5f",
    "role": "CompanyAdmin",
    "subsidiary_id": "18b97406-69da-4674-8152-5742734dd315",
    "subsidiary_name": "Subsidiary name",
    "team_ids": [
      "14c32c74-b361-4d12-a3da-b775c2f856dc"
    ],
    "type": "regular"
  }
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company id
id	path	string	true	Invite id
body	body	Invite	false	Invite attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Creates an invite to company

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/invites \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/invites HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/invites', headers = headers)

print(r.json())

const inputBody = '{
  "invite": {
    "company_id": "95444f0d-d0b2-4478-a186-51a26b420733",
    "company_name": "Company name LTD",
    "email": "mario.rossi@example.com",
    "firstname": "Mario",
    "lastname": "Rossi",
    "main_team_id": "bd8c7f2a-7b8a-46c5-a389-2f04bea0fa5f",
    "role": "CompanyAdmin",
    "subsidiary_id": "18b97406-69da-4674-8152-5742734dd315",
    "subsidiary_name": "Subsidiary name",
    "team_ids": [
      "14c32c74-b361-4d12-a3da-b775c2f856dc"
    ],
    "type": "regular"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/invites',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/invites', 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/invites");
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/invites", data)
    req.Header = headers

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

POST /api/v1/invites

Creates an invite and send an email to...

Body parameter

{
  "invite": {
    "company_id": "95444f0d-d0b2-4478-a186-51a26b420733",
    "company_name": "Company name LTD",
    "email": "mario.rossi@example.com",
    "firstname": "Mario",
    "lastname": "Rossi",
    "main_team_id": "bd8c7f2a-7b8a-46c5-a389-2f04bea0fa5f",
    "role": "CompanyAdmin",
    "subsidiary_id": "18b97406-69da-4674-8152-5742734dd315",
    "subsidiary_name": "Subsidiary name",
    "team_ids": [
      "14c32c74-b361-4d12-a3da-b775c2f856dc"
    ],
    "type": "regular"
  }
}

Parameters

Name	In	Type	Required	Description
body	body	Invite	false	Invite attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of invites for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/invites/by_company/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/invites/by_company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/invites/by_company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/invites/by_company/{company_id}',
{
  method: 'GET',

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

<?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/invites/by_company/{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/invites/by_company/{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/invites/by_company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/invites/by_company/{company_id}

Renders a list of invites for a given company id...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id

Example responses

200 Response

[
  {
    "invite": {
      "company_id": "95444f0d-d0b2-4478-a186-51a26b420733",
      "company_name": "Company name LTD",
      "email": "mario.rossi@example.com",
      "firstname": "Mario",
      "lastname": "Rossi",
      "main_team_id": "bd8c7f2a-7b8a-46c5-a389-2f04bea0fa5f",
      "role": "CompanyAdmin",
      "subsidiary_id": "18b97406-69da-4674-8152-5742734dd315",
      "subsidiary_name": "Subsidiary name",
      "team_ids": [
        "14c32c74-b361-4d12-a3da-b775c2f856dc"
      ],
      "type": "regular"
    }
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Invites

Renders an invite with given id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/invites/{id} \
  -H 'Accept: application/json'

GET https://api.fluida.io/api/v1/invites/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.fluida.io/api/v1/invites/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json'
};

fetch('https://api.fluida.io/api/v1/invites/{id}',
{
  method: 'GET',

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/invites/{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/invites/{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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/invites/{id}", data)
    req.Header = headers

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

GET /api/v1/invites/{id}

Renders an invite with given id...

Parameters

Name	In	Type	Required	Description
id	path	string	true	invite id

Example responses

200 Response

{
  "invite": {
    "company_id": "95444f0d-d0b2-4478-a186-51a26b420733",
    "company_name": "Company name LTD",
    "email": "mario.rossi@example.com",
    "firstname": "Mario",
    "lastname": "Rossi",
    "main_team_id": "bd8c7f2a-7b8a-46c5-a389-2f04bea0fa5f",
    "role": "CompanyAdmin",
    "subsidiary_id": "18b97406-69da-4674-8152-5742734dd315",
    "subsidiary_name": "Subsidiary name",
    "team_ids": [
      "14c32c74-b361-4d12-a3da-b775c2f856dc"
    ],
    "type": "regular"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Invite

Accepts an invite with given id

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/invites/{id}

PUT https://api.fluida.io/api/v1/invites/{id} HTTP/1.1
Host: api.fluida.io

import requests

r = requests.put('https://api.fluida.io/api/v1/invites/{id}')

print(r.json())

fetch('https://api.fluida.io/api/v1/invites/{id}',
{
  method: 'PUT'

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

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/invites/{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/invites/{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() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/invites/{id}", data)
    req.Header = headers

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

PUT /api/v1/invites/{id}

Accepts an invite with given id...

Parameters

Name	In	Type	Required	Description
id	path	string	true	invite id

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None

Justification

Creates justification

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/justifications \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/justifications HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/justifications', headers = headers)

print(r.json())

const inputBody = '{
  "additional_details": [],
  "additive": false,
  "approvers_ids": [
    "77f9ea79-de5d-4a24-b921-fbd5e89765fe",
    "0a97ed6d-d21d-42fd-8cba-cecb737c0d50"
  ],
  "company_id": "d6f981c7-42ef-43a6-8dd7-375a27b4d7fc",
  "contract_id": "301dfd4f-affc-4738-a4e4-c032f18ddbcf",
  "followers_ids": [
    "b8982531-6dab-4d78-a5db-2f88571eb183",
    "e0a9770d-830c-498c-b640-c5ed5d023bab",
    "59dd3c77-7d0b-4d76-9583-fab309736de9"
  ],
  "from_date": "2019-02-23",
  "from_time": "10:00:00",
  "justification_id": "26a838b3-ff09-4600-b0d0-bf7c17afd37c",
  "kind": "request",
  "notes": "Reprehenderit eligendi itaque eaque voluptate voluptas perspiciatis.",
  "presence": false,
  "requested_at": "2019-02-22 14:44:23.237271Z",
  "status": "requested",
  "subsidiary_id": "800e39aa-35a0-46fb-9ceb-b63100f7728e",
  "team_ids": [
    "f6d475eb-8f9c-46db-8a09-cd06940e6506",
    "b1229ffb-02cb-46a6-868e-d3a13fef06ce"
  ],
  "time": 115,
  "to_date": "2019-02-27",
  "to_time": "12:00:00",
  "type_id": "d1e85db8-d5e0-479e-a0c1-40c0d688e598",
  "type_label": "holiday",
  "type_name": "holiday"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/justifications', 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/justifications");
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/justifications", data)
    req.Header = headers

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

POST /api/v1/justifications

Creates justification...

Body parameter

{
  "additional_details": [],
  "additive": false,
  "approvers_ids": [
    "77f9ea79-de5d-4a24-b921-fbd5e89765fe",
    "0a97ed6d-d21d-42fd-8cba-cecb737c0d50"
  ],
  "company_id": "d6f981c7-42ef-43a6-8dd7-375a27b4d7fc",
  "contract_id": "301dfd4f-affc-4738-a4e4-c032f18ddbcf",
  "followers_ids": [
    "b8982531-6dab-4d78-a5db-2f88571eb183",
    "e0a9770d-830c-498c-b640-c5ed5d023bab",
    "59dd3c77-7d0b-4d76-9583-fab309736de9"
  ],
  "from_date": "2019-02-23",
  "from_time": "10:00:00",
  "justification_id": "26a838b3-ff09-4600-b0d0-bf7c17afd37c",
  "kind": "request",
  "notes": "Reprehenderit eligendi itaque eaque voluptate voluptas perspiciatis.",
  "presence": false,
  "requested_at": "2019-02-22 14:44:23.237271Z",
  "status": "requested",
  "subsidiary_id": "800e39aa-35a0-46fb-9ceb-b63100f7728e",
  "team_ids": [
    "f6d475eb-8f9c-46db-8a09-cd06940e6506",
    "b1229ffb-02cb-46a6-868e-d3a13fef06ce"
  ],
  "time": 115,
  "to_date": "2019-02-27",
  "to_time": "12:00:00",
  "type_id": "d1e85db8-d5e0-479e-a0c1-40c0d688e598",
  "type_label": "holiday",
  "type_name": "holiday"
}

Parameters

Name	In	Type	Required	Description
body	body	Justification	false	justification attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Approves chosen justification

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/justifications/approve/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/justifications/approve/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/justifications/approve/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "closer_id": "string",
  "notes": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/approve/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/justifications/approve/{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/justifications/approve/{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/justifications/approve/{id}", data)
    req.Header = headers

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

PUT /api/v1/justifications/approve/{id}

Approves chosen justification...

Body parameter

{
  "closer_id": "string",
  "notes": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	justification id
body	body	JustificationAction	false	justification attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Bulk Create justification

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/justifications/bulk \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/justifications/bulk HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/justifications/bulk', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "string",
  "entries": [
    {
      "contract_id": "string",
      "from_date": "2019-08-24",
      "from_duration": 0,
      "from_time": "string",
      "subsidiary_id": "string",
      "to_date": "2019-08-24",
      "to_duration": 0,
      "to_time": "string",
      "type_id": "string"
    }
  ],
  "requested_by": "string",
  "session_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/bulk',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/justifications/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/justifications/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{
        "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/justifications/bulk", data)
    req.Header = headers

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

POST /api/v1/justifications/bulk

Bulk Creates justifications

Body parameter

{
  "company_id": "string",
  "entries": [
    {
      "contract_id": "string",
      "from_date": "2019-08-24",
      "from_duration": 0,
      "from_time": "string",
      "subsidiary_id": "string",
      "to_date": "2019-08-24",
      "to_duration": 0,
      "to_time": "string",
      "type_id": "string"
    }
  ],
  "requested_by": "string",
  "session_id": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	object	false	Request body
» company_id	body	string	true	Company ID
» entries	body	[BulkJustificationParams]	false	Justifications
»» Bulk Justification Params	body	BulkJustificationParams	false	Bulk Justification Params
»»» contract_id	body	string	true	Contract Id
»»» from_date	body	string(date)	true	From Date
»»» from_duration	body	integer	false	Duration in the first day (minutes)
»»» from_time	body	string	false	From Time
»»» subsidiary_id	body	string	false	Subsidiary Id
»»» to_date	body	string(date)	false	To Date
»»» to_duration	body	integer	false	Duration in the last day (minutes)
»»» to_time	body	string	false	To Time
»»» type_id	body	string	true	Justification Type Id
» requested_by	body	string	false	Requester Contract ID
» session_id	body	string	false	Session ID

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a list justification entries for a given approver contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/justifications/by_approver/{approver_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/justifications/by_approver/{approver_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/justifications/by_approver/{approver_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/by_approver/{approver_id}',
{
  method: 'GET',

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

<?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/justifications/by_approver/{approver_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/justifications/by_approver/{approver_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/justifications/by_approver/{approver_id}", data)
    req.Header = headers

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

GET /api/v1/justifications/by_approver/{approver_id}

Renders a list justification entries for a given approver contract id...

Parameters

Name	In	Type	Required	Description
approver_id	path	string	true	approver id
start_date	query	string	false	Start date
end_date	query	string	false	End date
status	query	string	false	Status
type_id	query	string	false	Type Id
limit	query	string	false	limit

Example responses

200 Response

[
  {
    "additional_details": [],
    "additive": false,
    "approvers_ids": [
      "77f9ea79-de5d-4a24-b921-fbd5e89765fe",
      "0a97ed6d-d21d-42fd-8cba-cecb737c0d50"
    ],
    "company_id": "d6f981c7-42ef-43a6-8dd7-375a27b4d7fc",
    "contract_id": "301dfd4f-affc-4738-a4e4-c032f18ddbcf",
    "followers_ids": [
      "b8982531-6dab-4d78-a5db-2f88571eb183",
      "e0a9770d-830c-498c-b640-c5ed5d023bab",
      "59dd3c77-7d0b-4d76-9583-fab309736de9"
    ],
    "from_date": "2019-02-23",
    "from_time": "10:00:00",
    "justification_id": "26a838b3-ff09-4600-b0d0-bf7c17afd37c",
    "kind": "request",
    "notes": "Reprehenderit eligendi itaque eaque voluptate voluptas perspiciatis.",
    "presence": false,
    "requested_at": "2019-02-22 14:44:23.237271Z",
    "status": "requested",
    "subsidiary_id": "800e39aa-35a0-46fb-9ceb-b63100f7728e",
    "team_ids": [
      "f6d475eb-8f9c-46db-8a09-cd06940e6506",
      "b1229ffb-02cb-46a6-868e-d3a13fef06ce"
    ],
    "time": 115,
    "to_date": "2019-02-27",
    "to_time": "12:00:00",
    "type_id": "d1e85db8-d5e0-479e-a0c1-40c0d688e598",
    "type_label": "holiday",
    "type_name": "holiday"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Justifications

Renders a list justification entries for a given contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/justifications/by_contract/{contract_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/justifications/by_contract/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/justifications/by_contract/{contract_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/by_contract/{contract_id}',
{
  method: 'GET',

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

<?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/justifications/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/justifications/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/justifications/by_contract/{contract_id}", data)
    req.Header = headers

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

GET /api/v1/justifications/by_contract/{contract_id}

Renders a list justification entries for a given contract id...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id

Example responses

200 Response

[
  {
    "additional_details": [],
    "additive": false,
    "approvers_ids": [
      "77f9ea79-de5d-4a24-b921-fbd5e89765fe",
      "0a97ed6d-d21d-42fd-8cba-cecb737c0d50"
    ],
    "company_id": "d6f981c7-42ef-43a6-8dd7-375a27b4d7fc",
    "contract_id": "301dfd4f-affc-4738-a4e4-c032f18ddbcf",
    "followers_ids": [
      "b8982531-6dab-4d78-a5db-2f88571eb183",
      "e0a9770d-830c-498c-b640-c5ed5d023bab",
      "59dd3c77-7d0b-4d76-9583-fab309736de9"
    ],
    "from_date": "2019-02-23",
    "from_time": "10:00:00",
    "justification_id": "26a838b3-ff09-4600-b0d0-bf7c17afd37c",
    "kind": "request",
    "notes": "Reprehenderit eligendi itaque eaque voluptate voluptas perspiciatis.",
    "presence": false,
    "requested_at": "2019-02-22 14:44:23.237271Z",
    "status": "requested",
    "subsidiary_id": "800e39aa-35a0-46fb-9ceb-b63100f7728e",
    "team_ids": [
      "f6d475eb-8f9c-46db-8a09-cd06940e6506",
      "b1229ffb-02cb-46a6-868e-d3a13fef06ce"
    ],
    "time": 115,
    "to_date": "2019-02-27",
    "to_time": "12:00:00",
    "type_id": "d1e85db8-d5e0-479e-a0c1-40c0d688e598",
    "type_label": "holiday",
    "type_name": "holiday"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Justifications

Cancels chosen justification

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/justifications/cancel/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/justifications/cancel/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/justifications/cancel/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "closer_id": "string",
  "notes": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/cancel/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/justifications/cancel/{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/justifications/cancel/{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/justifications/cancel/{id}", data)
    req.Header = headers

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

PUT /api/v1/justifications/cancel/{id}

Cancels chosen justification...

Body parameter

{
  "closer_id": "string",
  "notes": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	justification id
body	body	JustificationAction	false	justification attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Rejects chosen justification

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/justifications/reject/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/justifications/reject/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/justifications/reject/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "closer_id": "string",
  "notes": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/reject/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/justifications/reject/{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/justifications/reject/{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/justifications/reject/{id}", data)
    req.Header = headers

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

PUT /api/v1/justifications/reject/{id}

Rejects chosen justification...

Body parameter

{
  "closer_id": "string",
  "notes": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	justification id
body	body	JustificationAction	false	justification attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a summary of justification types for a given contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/justifications/summary_by_contract/{contract_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/justifications/summary_by_contract/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/justifications/summary_by_contract/{contract_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/summary_by_contract/{contract_id}',
{
  method: 'GET',

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

<?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/justifications/summary_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/justifications/summary_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/justifications/summary_by_contract/{contract_id}", data)
    req.Header = headers

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

GET /api/v1/justifications/summary_by_contract/{contract_id}

Renders a summary of justification types for a given contract id...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id

Example responses

200 Response

[
  {
    "count": 0,
    "type_id": "string",
    "type_label": "string"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	JustificationSummaries

Renders a list of justifications to be approved by a given contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/justifications/to_be_approved/{approver_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/justifications/to_be_approved/{approver_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/justifications/to_be_approved/{approver_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/to_be_approved/{approver_id}',
{
  method: 'GET',

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

<?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/justifications/to_be_approved/{approver_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/justifications/to_be_approved/{approver_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/justifications/to_be_approved/{approver_id}", data)
    req.Header = headers

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

GET /api/v1/justifications/to_be_approved/{approver_id}

Renders a list of justifications to be approved by a given contract id...

Parameters

Name	In	Type	Required	Description
approver_id	path	string	true	approver id

Example responses

200 Response

[
  {
    "additional_details": [],
    "additive": false,
    "approvers_ids": [
      "77f9ea79-de5d-4a24-b921-fbd5e89765fe",
      "0a97ed6d-d21d-42fd-8cba-cecb737c0d50"
    ],
    "company_id": "d6f981c7-42ef-43a6-8dd7-375a27b4d7fc",
    "contract_id": "301dfd4f-affc-4738-a4e4-c032f18ddbcf",
    "followers_ids": [
      "b8982531-6dab-4d78-a5db-2f88571eb183",
      "e0a9770d-830c-498c-b640-c5ed5d023bab",
      "59dd3c77-7d0b-4d76-9583-fab309736de9"
    ],
    "from_date": "2019-02-23",
    "from_time": "10:00:00",
    "justification_id": "26a838b3-ff09-4600-b0d0-bf7c17afd37c",
    "kind": "request",
    "notes": "Reprehenderit eligendi itaque eaque voluptate voluptas perspiciatis.",
    "presence": false,
    "requested_at": "2019-02-22 14:44:23.237271Z",
    "status": "requested",
    "subsidiary_id": "800e39aa-35a0-46fb-9ceb-b63100f7728e",
    "team_ids": [
      "f6d475eb-8f9c-46db-8a09-cd06940e6506",
      "b1229ffb-02cb-46a6-868e-d3a13fef06ce"
    ],
    "time": 115,
    "to_date": "2019-02-27",
    "to_time": "12:00:00",
    "type_id": "d1e85db8-d5e0-479e-a0c1-40c0d688e598",
    "type_label": "holiday",
    "type_name": "holiday"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Justifications

Creates justification type

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/justifications/types \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/justifications/types HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/justifications/types', headers = headers)

print(r.json())

const inputBody = '{
  "additional_details": [],
  "additive": false,
  "company_id": "4f64013e-0663-440d-b433-6ec7465ae899",
  "id": "54c335fc-8b95-4b6c-b15e-22a9b95d91ce",
  "justification_type_id": "46e842b1-56ef-4e1b-8a5c-545130c257eb",
  "name": "velit",
  "presence": false,
  "requires_approval": false,
  "system_default": false
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/types',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/justifications/types', 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/justifications/types");
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/justifications/types", data)
    req.Header = headers

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

POST /api/v1/justifications/types

Creates justification type...

Body parameter

{
  "additional_details": [],
  "additive": false,
  "company_id": "4f64013e-0663-440d-b433-6ec7465ae899",
  "id": "54c335fc-8b95-4b6c-b15e-22a9b95d91ce",
  "justification_type_id": "46e842b1-56ef-4e1b-8a5c-545130c257eb",
  "name": "velit",
  "presence": false,
  "requires_approval": false,
  "system_default": false
}

Parameters

Name	In	Type	Required	Description
body	body	JustificationType	false	justification type attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a list justification types for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/justifications/types/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/justifications/types/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/justifications/types/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/types/{company_id}',
{
  method: 'GET',

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

<?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/justifications/types/{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/justifications/types/{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/justifications/types/{company_id}", data)
    req.Header = headers

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

GET /api/v1/justifications/types/{company_id}

Renders a list justification types for a given company id...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id

Example responses

200 Response

[
  {
    "additional_details": [],
    "additive": false,
    "company_id": "4f64013e-0663-440d-b433-6ec7465ae899",
    "id": "54c335fc-8b95-4b6c-b15e-22a9b95d91ce",
    "justification_type_id": "46e842b1-56ef-4e1b-8a5c-545130c257eb",
    "name": "velit",
    "presence": false,
    "requires_approval": false,
    "system_default": false
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	JustificationTypes

Delete a justification type

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/justifications/types/{company_id}/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/justifications/types/{company_id}/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/justifications/types/{company_id}/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/types/{company_id}/{id}',
{
  method: 'DELETE',

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

<?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/justifications/types/{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/justifications/types/{company_id}/{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/justifications/types/{company_id}/{id}", data)
    req.Header = headers

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

DELETE /api/v1/justifications/types/{company_id}/{id}

Delete a justification type...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	justification type id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Update a justification type

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/justifications/types/{company_id}/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/justifications/types/{company_id}/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/justifications/types/{company_id}/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "additional_details": [],
  "additive": false,
  "company_id": "4f64013e-0663-440d-b433-6ec7465ae899",
  "id": "54c335fc-8b95-4b6c-b15e-22a9b95d91ce",
  "justification_type_id": "46e842b1-56ef-4e1b-8a5c-545130c257eb",
  "name": "velit",
  "presence": false,
  "requires_approval": false,
  "system_default": false
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/types/{company_id}/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/justifications/types/{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/justifications/types/{company_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/justifications/types/{company_id}/{id}", data)
    req.Header = headers

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

PUT /api/v1/justifications/types/{company_id}/{id}

Update a justification type...

Body parameter

{
  "additional_details": [],
  "additive": false,
  "company_id": "4f64013e-0663-440d-b433-6ec7465ae899",
  "id": "54c335fc-8b95-4b6c-b15e-22a9b95d91ce",
  "justification_type_id": "46e842b1-56ef-4e1b-8a5c-545130c257eb",
  "name": "velit",
  "presence": false,
  "requires_approval": false,
  "system_default": false
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	justification type id
body	body	JustificationType	false	justification type attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a justification entry for a given id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/justifications/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/justifications/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/justifications/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/{id}',
{
  method: 'GET',

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

<?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/justifications/{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/justifications/{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/justifications/{id}", data)
    req.Header = headers

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

GET /api/v1/justifications/{id}

Renders a justification entry for a given id...

Parameters

Name	In	Type	Required	Description
id	path	string	true	justification id

Example responses

200 Response

{
  "additional_details": [],
  "additive": false,
  "approvers_ids": [
    "77f9ea79-de5d-4a24-b921-fbd5e89765fe",
    "0a97ed6d-d21d-42fd-8cba-cecb737c0d50"
  ],
  "company_id": "d6f981c7-42ef-43a6-8dd7-375a27b4d7fc",
  "contract_id": "301dfd4f-affc-4738-a4e4-c032f18ddbcf",
  "followers_ids": [
    "b8982531-6dab-4d78-a5db-2f88571eb183",
    "e0a9770d-830c-498c-b640-c5ed5d023bab",
    "59dd3c77-7d0b-4d76-9583-fab309736de9"
  ],
  "from_date": "2019-02-23",
  "from_time": "10:00:00",
  "justification_id": "26a838b3-ff09-4600-b0d0-bf7c17afd37c",
  "kind": "request",
  "notes": "Reprehenderit eligendi itaque eaque voluptate voluptas perspiciatis.",
  "presence": false,
  "requested_at": "2019-02-22 14:44:23.237271Z",
  "status": "requested",
  "subsidiary_id": "800e39aa-35a0-46fb-9ceb-b63100f7728e",
  "team_ids": [
    "f6d475eb-8f9c-46db-8a09-cd06940e6506",
    "b1229ffb-02cb-46a6-868e-d3a13fef06ce"
  ],
  "time": 115,
  "to_date": "2019-02-27",
  "to_time": "12:00:00",
  "type_id": "d1e85db8-d5e0-479e-a0c1-40c0d688e598",
  "type_label": "holiday",
  "type_name": "holiday"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Justification

Updates chosen justification

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/justifications/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/justifications/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/justifications/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "additional_details": [],
  "additive": false,
  "approvers_ids": [
    "77f9ea79-de5d-4a24-b921-fbd5e89765fe",
    "0a97ed6d-d21d-42fd-8cba-cecb737c0d50"
  ],
  "company_id": "d6f981c7-42ef-43a6-8dd7-375a27b4d7fc",
  "contract_id": "301dfd4f-affc-4738-a4e4-c032f18ddbcf",
  "followers_ids": [
    "b8982531-6dab-4d78-a5db-2f88571eb183",
    "e0a9770d-830c-498c-b640-c5ed5d023bab",
    "59dd3c77-7d0b-4d76-9583-fab309736de9"
  ],
  "from_date": "2019-02-23",
  "from_time": "10:00:00",
  "justification_id": "26a838b3-ff09-4600-b0d0-bf7c17afd37c",
  "kind": "request",
  "notes": "Reprehenderit eligendi itaque eaque voluptate voluptas perspiciatis.",
  "presence": false,
  "requested_at": "2019-02-22 14:44:23.237271Z",
  "status": "requested",
  "subsidiary_id": "800e39aa-35a0-46fb-9ceb-b63100f7728e",
  "team_ids": [
    "f6d475eb-8f9c-46db-8a09-cd06940e6506",
    "b1229ffb-02cb-46a6-868e-d3a13fef06ce"
  ],
  "time": 115,
  "to_date": "2019-02-27",
  "to_time": "12:00:00",
  "type_id": "d1e85db8-d5e0-479e-a0c1-40c0d688e598",
  "type_label": "holiday",
  "type_name": "holiday"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/justifications/{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/justifications/{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/justifications/{id}", data)
    req.Header = headers

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

PUT /api/v1/justifications/{id}

Updates chosen justification...

Body parameter

{
  "additional_details": [],
  "additive": false,
  "approvers_ids": [
    "77f9ea79-de5d-4a24-b921-fbd5e89765fe",
    "0a97ed6d-d21d-42fd-8cba-cecb737c0d50"
  ],
  "company_id": "d6f981c7-42ef-43a6-8dd7-375a27b4d7fc",
  "contract_id": "301dfd4f-affc-4738-a4e4-c032f18ddbcf",
  "followers_ids": [
    "b8982531-6dab-4d78-a5db-2f88571eb183",
    "e0a9770d-830c-498c-b640-c5ed5d023bab",
    "59dd3c77-7d0b-4d76-9583-fab309736de9"
  ],
  "from_date": "2019-02-23",
  "from_time": "10:00:00",
  "justification_id": "26a838b3-ff09-4600-b0d0-bf7c17afd37c",
  "kind": "request",
  "notes": "Reprehenderit eligendi itaque eaque voluptate voluptas perspiciatis.",
  "presence": false,
  "requested_at": "2019-02-22 14:44:23.237271Z",
  "status": "requested",
  "subsidiary_id": "800e39aa-35a0-46fb-9ceb-b63100f7728e",
  "team_ids": [
    "f6d475eb-8f9c-46db-8a09-cd06940e6506",
    "b1229ffb-02cb-46a6-868e-d3a13fef06ce"
  ],
  "time": 115,
  "to_date": "2019-02-27",
  "to_time": "12:00:00",
  "type_id": "d1e85db8-d5e0-479e-a0c1-40c0d688e598",
  "type_label": "holiday",
  "type_name": "holiday"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	justification id
body	body	Justification	false	justification attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Adds notes to chosen justification

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/justifications/{id}/add_notes \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/justifications/{id}/add_notes HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/justifications/{id}/add_notes', headers = headers)

print(r.json())

const inputBody = '{
  "notes": "string",
  "updated_by": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/justifications/{id}/add_notes',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/justifications/{id}/add_notes', 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/justifications/{id}/add_notes");
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/justifications/{id}/add_notes", data)
    req.Header = headers

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

PUT /api/v1/justifications/{id}/add_notes

Adds notes to chosen justification

Body parameter

{
  "notes": "string",
  "updated_by": "string"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	justification id
body	body	JustificationNotes	false	Justification notes attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Notification

Renders a list of notification entries for a given recipient

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/notifications/by_recipient/{recipient_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/notifications/by_recipient/{recipient_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/notifications/by_recipient/{recipient_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/notifications/by_recipient/{recipient_id}',
{
  method: 'GET',

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

<?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/notifications/by_recipient/{recipient_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/notifications/by_recipient/{recipient_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/notifications/by_recipient/{recipient_id}", data)
    req.Header = headers

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

GET /api/v1/notifications/by_recipient/{recipient_id}

Renders a list of notification entries for a given recipient...

Parameters

Name	In	Type	Required	Description
recipient_id	path	string	true	recipient id

Example responses

200 Response

[
  {
    "company_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
    "content": {
      "approvers_ids": [
        "13d2371a-326d-4b96-912f-c20f2c2cef15"
      ],
      "contract_id": "90725746-5c2d-44fc-908f-96e50f8e65ba",
      "followers_ids": [
        "c1f86232-2dfb-42a5-aff0-65521a3a01ac",
        "e80ee330-aa3a-4f8d-be8f-748869705b5d"
      ],
      "from_date": "2019-02-26",
      "from_time": "10:00:00",
      "id": "e508bd7c-aa20-4cfc-a179-e2324b416e29",
      "notes": "Quisquam atque impedit accusantium consequatur sint distinctio aut est explicabo.",
      "status": "requested",
      "to_date": "2019-03-02",
      "to_time": "12:00:00",
      "type_id": "holiday",
      "type_label": "quia",
      "type_name": "adipisci"
    },
    "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f",
    "read": false,
    "recipient_id": "ddbb23bb-1cbe-48ce-bd55-43908e623e1f",
    "template": {
      "bindings": {},
      "text": "Illum modi dicta ipsa sapiente qui."
    },
    "type": "justification"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Notifications

Renders a notification entries count for a given recipient

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/notifications/by_recipient/{recipient_id}/count \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/notifications/by_recipient/{recipient_id}/count HTTP/1.1
Host: api.fluida.io

import requests
headers = {
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/notifications/by_recipient/{recipient_id}/count', headers = headers)

print(r.json())

const headers = {
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/notifications/by_recipient/{recipient_id}/count',
{
  method: 'GET',

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

<?php

require 'vendor/autoload.php';

$headers = array(
    '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/notifications/by_recipient/{recipient_id}/count', 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/notifications/by_recipient/{recipient_id}/count");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/notifications/by_recipient/{recipient_id}/count", data)
    req.Header = headers

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

GET /api/v1/notifications/by_recipient/{recipient_id}/count

Renders a notification entries count for a given recipient...

Parameters

Name	In	Type	Required	Description
recipient_id	path	string	true	recipient id

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

Sets or updates as push notification token

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/notifications/push_notification_token \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/notifications/push_notification_token HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/notifications/push_notification_token', headers = headers)

print(r.json())

const inputBody = '{
  "platform": "string",
  "token": "string",
  "user_id": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/notifications/push_notification_token',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/notifications/push_notification_token', 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/notifications/push_notification_token");
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/notifications/push_notification_token", data)
    req.Header = headers

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

POST /api/v1/notifications/push_notification_token

Sets or updates as push notification token

Body parameter

{
  "platform": "string",
  "token": "string",
  "user_id": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	PushNotificationToken	false	push notification token attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Set as read chosen notification

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/notifications/read/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/notifications/read/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/notifications/read/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/notifications/read/{id}',
{
  method: 'PUT',

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

<?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/notifications/read/{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/notifications/read/{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/notifications/read/{id}", data)
    req.Header = headers

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

PUT /api/v1/notifications/read/{id}

Set as read chosen notification...

Parameters

Name	In	Type	Required	Description
id	path	string	true	subsidiary id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Partner

Creates a Dealer

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/partner/dealer \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/partner/dealer HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/partner/dealer', headers = headers)

print(r.json())

const inputBody = '{
  "code": "string",
  "commercial_contact": {},
  "customization_data": {},
  "name": "string",
  "partner_code": "string",
  "preferences": {}
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/partner/dealer',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/partner/dealer', 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/partner/dealer");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/partner/dealer", data)
    req.Header = headers

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

POST /api/v1/partner/dealer

Creates a Dealer

Body parameter

{
  "code": "string",
  "commercial_contact": {},
  "customization_data": {},
  "name": "string",
  "partner_code": "string",
  "preferences": {}
}

Parameters

Name	In	Type	Required	Description
body	body	DealerData	false	Dealer Data

Example responses

400 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Get Dealer by ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/partner/dealer/{dealer_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/partner/dealer/{dealer_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/partner/dealer/{dealer_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/partner/dealer/{dealer_id}',
{
  method: 'GET',

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

<?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/partner/dealer/{dealer_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/partner/dealer/{dealer_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/partner/dealer/{dealer_id}", data)
    req.Header = headers

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

GET /api/v1/partner/dealer/{dealer_id}

Renders a Dealer

Parameters

Name	In	Type	Required	Description
dealer_id	path	string	true	Dealer ID

Example responses

200 Response

{
  "code": "string",
  "commercial_contact": {},
  "customization_data": {},
  "id": "string",
  "name": "string",
  "partner_code": "string",
  "preferences": {},
  "status": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Dealer
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Creates a Reseller

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/partner/reseller \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/partner/reseller HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/partner/reseller', headers = headers)

print(r.json())

const inputBody = '{
  "reseller": {
    "allowed_subscription_plans": [
      "rex-professional",
      "rex-professional-annuale"
    ],
    "code": "REX",
    "commercial_contact": {
      "email": "foo@bar.com",
      "name": "Some Name"
    },
    "customization_data": {},
    "name": "Reseller",
    "partner_code": "XXX",
    "preferences": {
      "foo": "bar"
    },
    "subscription_customer_id": "SDADAAA"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/partner/reseller',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/partner/reseller', 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/partner/reseller");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/partner/reseller", data)
    req.Header = headers

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

POST /api/v1/partner/reseller

Creates a Reseller

Body parameter

{
  "reseller": {
    "allowed_subscription_plans": [
      "rex-professional",
      "rex-professional-annuale"
    ],
    "code": "REX",
    "commercial_contact": {
      "email": "foo@bar.com",
      "name": "Some Name"
    },
    "customization_data": {},
    "name": "Reseller",
    "partner_code": "XXX",
    "preferences": {
      "foo": "bar"
    },
    "subscription_customer_id": "SDADAAA"
  }
}

Parameters

Name	In	Type	Required	Description
body	body	ResellerData	false	ResellerData

Example responses

400 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Renders a Company Activation Request

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/partner/reseller/company/activation_request/{activation_request_id} \
  -H 'Accept: application/json'

GET https://api.fluida.io/api/v1/partner/reseller/company/activation_request/{activation_request_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.fluida.io/api/v1/partner/reseller/company/activation_request/{activation_request_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json'
};

fetch('https://api.fluida.io/api/v1/partner/reseller/company/activation_request/{activation_request_id}',
{
  method: 'GET',

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/partner/reseller/company/activation_request/{activation_request_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/partner/reseller/company/activation_request/{activation_request_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"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/partner/reseller/company/activation_request/{activation_request_id}", data)
    req.Header = headers

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

GET /api/v1/partner/reseller/company/activation_request/{activation_request_id}

Renders a Company Activation Request

Parameters

Name	In	Type	Required	Description
activation_request_id	path	string	true	Activation Request ID

Example responses

200 Response

{
  "activation_request_id": "7be09252-bd33-4197-8d54-a7884091edab",
  "activation_request_status": "pending",
  "company_address": "14138 Cummerata Brooks",
  "company_billing_email": "billing-1@example.com",
  "company_city": "Ritchieberg",
  "company_codice_destinatario": "UO1234",
  "company_country": "Lithuania",
  "company_fiscal_code": "ABCDEF12A01H501-1",
  "company_name": "Marks-Kemmer",
  "company_owner_email": "company-admin-0@example.com",
  "company_owner_firstname": "Klaus",
  "company_owner_lastname": "Faker",
  "company_pec": "foo.bar@pec.it",
  "company_phone": "07881 836703",
  "company_province": "TO",
  "company_vat_id": "123456789-0",
  "company_zip": "92328",
  "external_customer_id": "ee044580-b980-4398-8f6c-1e9897fe59c2",
  "external_subscription_id": "1e81d4d5-b48e-4a12-af7f-7af734ccb2c2",
  "number_of_employees": 10,
  "plan_quantity": 15,
  "reseller_id": "a5c79385-7df0-403d-a96d-bf7cffaaf2d7",
  "reseller_name": "Partner Fake",
  "subscription_expiration_date": "2019-09-30T00:00:00Z",
  "subscription_plan": "professional",
  "subscription_status": "active",
  "trial_expiration_date": "2019-06-30T00:00:00Z"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	CompanyActivationRequest
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Get Reseller by ID

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/partner/reseller/{reseller_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/partner/reseller/{reseller_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}',
{
  method: 'GET',

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

<?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/partner/reseller/{reseller_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/partner/reseller/{reseller_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/partner/reseller/{reseller_id}", data)
    req.Header = headers

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

GET /api/v1/partner/reseller/{reseller_id}

Renders a Reseller

Parameters

Name	In	Type	Required	Description
reseller_id	path	string	true	Reseller ID

Example responses

200 Response

{
  "allowed_subscription_plans": [
    "rex-professional",
    "rex-professional-annuale"
  ],
  "code": "REX",
  "commercial_contact": {
    "email": "foo@bar.com",
    "name": "Some Name"
  },
  "customization_data": {},
  "id": "850a9164-4357-4ed0-9888-54b98a7c3342",
  "name": "Reseller",
  "partner_code": "XXX",
  "preferences": {
    "foo": "bar"
  },
  "status": "active",
  "subscription_customer_id": "SDADAAA"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Reseller
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Creates a Company Activation Request

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/company/create_activation_request \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/company/create_activation_request HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/company/create_activation_request', headers = headers)

print(r.json())

const inputBody = '{
  "activation_request": {
    "company_address": "14138 Cummerata Brooks",
    "company_billing_email": "billing-1@example.com",
    "company_city": "Ritchieberg",
    "company_codice_destinatario": "UO1234",
    "company_country": "Lithuania",
    "company_fiscal_code": "ABCDEF12A01H501-1",
    "company_name": "Marks-Kemmer",
    "company_owner_email": "company-admin-0@example.com",
    "company_owner_firstname": "Klaus",
    "company_owner_lastname": "Faker",
    "company_pec": "foo.bar@pec.it",
    "company_phone": "07881 836703",
    "company_province": "TO",
    "company_vat_id": "123456789-0",
    "company_zip": "92328",
    "external_customer_id": "3aad41a7-0350-4219-9e54-66b832c8e14c",
    "external_subscription_id": "30aa6893-6801-4659-8c36-db0bb2d0bf43",
    "number_of_employees": 10,
    "plan_quantity": 15,
    "reseller_id": "d547cc57-5bd6-4a8c-a1ea-7e9b6ffca0e7",
    "subscription_expiration_date": "2019-09-30T00:00:00Z",
    "subscription_plan": "professional",
    "subscription_status": "active",
    "trial_expiration_date": "2019-06-30T00:00:00Z"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/company/create_activation_request',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/partner/reseller/{reseller_id}/company/create_activation_request', 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/partner/reseller/{reseller_id}/company/create_activation_request");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/company/create_activation_request", data)
    req.Header = headers

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

POST /api/v1/partner/reseller/{reseller_id}/company/create_activation_request

Creates a Company Activation Request

Body parameter

{
  "activation_request": {
    "company_address": "14138 Cummerata Brooks",
    "company_billing_email": "billing-1@example.com",
    "company_city": "Ritchieberg",
    "company_codice_destinatario": "UO1234",
    "company_country": "Lithuania",
    "company_fiscal_code": "ABCDEF12A01H501-1",
    "company_name": "Marks-Kemmer",
    "company_owner_email": "company-admin-0@example.com",
    "company_owner_firstname": "Klaus",
    "company_owner_lastname": "Faker",
    "company_pec": "foo.bar@pec.it",
    "company_phone": "07881 836703",
    "company_province": "TO",
    "company_vat_id": "123456789-0",
    "company_zip": "92328",
    "external_customer_id": "3aad41a7-0350-4219-9e54-66b832c8e14c",
    "external_subscription_id": "30aa6893-6801-4659-8c36-db0bb2d0bf43",
    "number_of_employees": 10,
    "plan_quantity": 15,
    "reseller_id": "d547cc57-5bd6-4a8c-a1ea-7e9b6ffca0e7",
    "subscription_expiration_date": "2019-09-30T00:00:00Z",
    "subscription_plan": "professional",
    "subscription_status": "active",
    "trial_expiration_date": "2019-06-30T00:00:00Z"
  }
}

Parameters

Name	In	Type	Required	Description
reseller_id	path	string	true	Reseller ID
body	body	CompanyActivationRequestData	false	Activation Request

Example responses

200 Response

{
  "activation_request_id": "128a1a89-0f6d-43bb-bf1e-6cee3b251e92"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	CompanyActivationResponse
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Creates a Shipping Order

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders', headers = headers)

print(r.json())

const inputBody = '{
  "shipping_order": {
    "billing_address": {
      "address": "Chestnut Street 92",
      "city": "Louisville",
      "codice_destinatario": "000000",
      "company": "ACME ltd",
      "country": "US",
      "first_name": "Bob",
      "last_name": "Norman",
      "pec": "a@b.com",
      "phone": "555-625-1199",
      "province": "Kentucky",
      "province_code": "KY",
      "vat_id": "AAA123",
      "zip": "40202"
    },
    "currency": "EUR",
    "discount_codes": [
      {
        "amount": "1.00",
        "code": "TENOFF",
        "type": "fixed_amount"
      }
    ],
    "email": "foo@bar.com",
    "external_customer_id": "6085191e-63ba-4207-ba77-73a0ce9a8e96",
    "external_order_id": "2fb79891-a1dc-432c-a7e7-01cdb21f8fb0",
    "financial_status": "paid",
    "fulfillment_status": "null",
    "line_items": [
      {
        "external_item_id": "23bfc990-879a-422c-bbaf-753ca1bfb313",
        "name": "IPod Touch 8GB - Black",
        "price": "199.00",
        "quantity": 1,
        "sku": "IPOD2009BLACK"
      }
    ],
    "note": "some note",
    "reseller_id": "243c1973-b325-4ce5-a925-24fc92b1ba19",
    "shipping_address": {
      "address": "Chestnut Street 92",
      "city": "Louisville",
      "company": "ACME ltd",
      "country": "US",
      "first_name": "Bob",
      "last_name": "Norman",
      "phone": "555-625-1199",
      "province": "Kentucky",
      "province_code": "KY",
      "zip": "40202"
    },
    "shipping_price": "5.00",
    "subtotal_price": "73.00",
    "total_discounts": "1.00",
    "total_line_items_price": "74.00",
    "total_price": "100.00",
    "total_tax": "22.00"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/partner/reseller/{reseller_id}/orders', 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/partner/reseller/{reseller_id}/orders");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders", data)
    req.Header = headers

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

POST /api/v1/partner/reseller/{reseller_id}/orders

Creates an Shipping Order from Reseller

Body parameter

{
  "shipping_order": {
    "billing_address": {
      "address": "Chestnut Street 92",
      "city": "Louisville",
      "codice_destinatario": "000000",
      "company": "ACME ltd",
      "country": "US",
      "first_name": "Bob",
      "last_name": "Norman",
      "pec": "a@b.com",
      "phone": "555-625-1199",
      "province": "Kentucky",
      "province_code": "KY",
      "vat_id": "AAA123",
      "zip": "40202"
    },
    "currency": "EUR",
    "discount_codes": [
      {
        "amount": "1.00",
        "code": "TENOFF",
        "type": "fixed_amount"
      }
    ],
    "email": "foo@bar.com",
    "external_customer_id": "6085191e-63ba-4207-ba77-73a0ce9a8e96",
    "external_order_id": "2fb79891-a1dc-432c-a7e7-01cdb21f8fb0",
    "financial_status": "paid",
    "fulfillment_status": "null",
    "line_items": [
      {
        "external_item_id": "23bfc990-879a-422c-bbaf-753ca1bfb313",
        "name": "IPod Touch 8GB - Black",
        "price": "199.00",
        "quantity": 1,
        "sku": "IPOD2009BLACK"
      }
    ],
    "note": "some note",
    "reseller_id": "243c1973-b325-4ce5-a925-24fc92b1ba19",
    "shipping_address": {
      "address": "Chestnut Street 92",
      "city": "Louisville",
      "company": "ACME ltd",
      "country": "US",
      "first_name": "Bob",
      "last_name": "Norman",
      "phone": "555-625-1199",
      "province": "Kentucky",
      "province_code": "KY",
      "zip": "40202"
    },
    "shipping_price": "5.00",
    "subtotal_price": "73.00",
    "total_discounts": "1.00",
    "total_line_items_price": "74.00",
    "total_price": "100.00",
    "total_tax": "22.00"
  }
}

Parameters

Name	In	Type	Required	Description
reseller_id	path	string	true	Reseller ID
body	body	ShippingOrderData	false	Order Data

Example responses

200 Response

{
  "order_id": "ea2e3533-4969-43e1-b1e4-fc8f14907a67"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ShippingOrderResponse
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Renders a Shipping Order by external id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id}',
{
  method: 'GET',

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

<?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/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_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/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_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/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id}", data)
    req.Header = headers

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

GET /api/v1/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id}

Renders a Shipping Order by external id

Parameters

Name	In	Type	Required	Description
reseller_id	path	string	true	Reseller ID
external_order_id	path	string	true	External Order ID

Example responses

200 Response

{
  "billing_address": {
    "address": "Chestnut Street 92",
    "city": "Louisville",
    "codice_destinatario": "000000",
    "company": "ACME ltd",
    "country": "US",
    "first_name": "Bob",
    "last_name": "Norman",
    "pec": "a@b.com",
    "phone": "555-625-1199",
    "province": "Kentucky",
    "province_code": "KY",
    "vat_id": "AAA123",
    "zip": "40202"
  },
  "currency": "EUR",
  "discount_codes": [
    {
      "amount": "1.00",
      "code": "TENOFF",
      "type": "fixed_amount"
    }
  ],
  "email": "foo@bar.com",
  "external_customer_id": "b7c1d61b-55ac-4bd4-844f-26755618ad17",
  "external_order_id": "3c0b4520-c30a-499e-9ba7-9534d80b6149",
  "financial_status": "paid",
  "fulfillment_status": "null",
  "inserted_at": "2020-01-28T12:00:00Z",
  "line_items": [
    {
      "external_item_id": "00df6c5c-4d54-467a-a5ad-6b65d5025ee5",
      "item_id": "e6515eaa-40d1-408b-9d09-bff39849963d",
      "name": "IPod Touch 8GB - Black",
      "price": "199.00",
      "quantity": 1,
      "sku": "IPOD2009BLACK"
    }
  ],
  "note": "some note",
  "order_id": "a58c927f-5467-41f0-be84-d0e4c554c26e",
  "reseller_id": "eff57b20-64f0-40f1-9a9b-2c21d67c0bf4",
  "shipping_address": {
    "address": "Chestnut Street 92",
    "city": "Louisville",
    "company": "ACME ltd",
    "country": "US",
    "first_name": "Bob",
    "last_name": "Norman",
    "phone": "555-625-1199",
    "province": "Kentucky",
    "province_code": "KY",
    "zip": "40202"
  },
  "shipping_price": "5.00",
  "subtotal_price": "73.00",
  "total_discounts": "1.00",
  "total_line_items_price": "74.00",
  "total_price": "100.00",
  "total_tax": "22.00",
  "updated_at": "2020-01-29T12:00:00Z"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ShippingOrder
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Updates a Shipping Order

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id}', headers = headers)

print(r.json())

const inputBody = '{
  "shipping_order": {
    "email": "foo@bar.com",
    "external_customer_id": "e175e556-65c6-48be-aae0-63aaa2163058",
    "financial_status": "paid",
    "fulfillment_status": "null",
    "note": "some note",
    "shipping_address": {
      "address": "Chestnut Street 92",
      "city": "Louisville",
      "company": "ACME ltd",
      "country": "US",
      "first_name": "Bob",
      "last_name": "Norman",
      "phone": "555-625-1199",
      "province": "Kentucky",
      "province_code": "KY",
      "zip": "40202"
    }
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_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/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_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{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id}", data)
    req.Header = headers

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

PUT /api/v1/partner/reseller/{reseller_id}/orders/by_external_id/{external_order_id}

Updates an Shipping Order from Reseller

Body parameter

{
  "shipping_order": {
    "email": "foo@bar.com",
    "external_customer_id": "e175e556-65c6-48be-aae0-63aaa2163058",
    "financial_status": "paid",
    "fulfillment_status": "null",
    "note": "some note",
    "shipping_address": {
      "address": "Chestnut Street 92",
      "city": "Louisville",
      "company": "ACME ltd",
      "country": "US",
      "first_name": "Bob",
      "last_name": "Norman",
      "phone": "555-625-1199",
      "province": "Kentucky",
      "province_code": "KY",
      "zip": "40202"
    }
  }
}

Parameters

Name	In	Type	Required	Description
reseller_id	path	string	true	Reseller ID
external_order_id	path	string	true	External Order ID
body	body	ShippingOrderUpdateData	false	Order Data

Example responses

400 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Gets Company Subscription Status

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/subscription/{external_subscription_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/subscription/{external_subscription_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/subscription/{external_subscription_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/subscription/{external_subscription_id}',
{
  method: 'GET',

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

<?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/partner/reseller/{reseller_id}/subscription/{external_subscription_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/partner/reseller/{reseller_id}/subscription/{external_subscription_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/partner/reseller/{reseller_id}/subscription/{external_subscription_id}", data)
    req.Header = headers

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

GET /api/v1/partner/reseller/{reseller_id}/subscription/{external_subscription_id}

Gets Company Subscription Status

Parameters

Name	In	Type	Required	Description
reseller_id	path	string	true	Reseller ID
external_subscription_id	path	string	true	Subscription ID in reseller systems

Example responses

200 Response

{
  "activation_request_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "active_contracts": 3,
  "available_plan_quantity": 4,
  "billing_period": "year",
  "billing_period_unit": 1,
  "can_add_new_contracts": true,
  "company_id": "cbf8a90b-e30c-4134-9612-fbb2ceca017a",
  "external_customer_id": "ac665579-0691-4e99-bd88-bca62df9166f",
  "external_subscription_id": "d16ecef6-ebb0-49cf-81d1-100311f3a5d9",
  "max_contracts": 10,
  "name": "Beer, Effertz and Murazik",
  "pending_invites": 3,
  "plan_quantity": 10,
  "subscription_expiration_date": "2019-09-30T00:00:00Z",
  "subscription_plan": "starter",
  "subscription_status": "active",
  "trial_expiration_date": "2019-07-30T00:00:00Z",
  "used_plan_quantity": 6
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ResellerSubscriptionStatus
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
404	Not Found	Not Found	NotFound

Updates Company Subscription

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/subscription/{external_subscription_id}/update \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/subscription/{external_subscription_id}/update HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/subscription/{external_subscription_id}/update', headers = headers)

print(r.json())

const inputBody = '{
  "subscription": {
    "external_customer_id": "93c4e53b-9a16-4da4-919f-ab5412e532e4",
    "external_subscription_id": "8eea702c-f14c-4d2f-8c0c-0ff7b1813476",
    "plan_quantity": 10,
    "subscription_expiration_date": "2019-09-30T00:00:00Z",
    "subscription_plan": "starter",
    "subscription_status": "active",
    "trial_expiration_date": "2019-07-30T00:00:00Z"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/subscription/{external_subscription_id}/update',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/partner/reseller/{reseller_id}/subscription/{external_subscription_id}/update', 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/partner/reseller/{reseller_id}/subscription/{external_subscription_id}/update");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/partner/reseller/{reseller_id}/subscription/{external_subscription_id}/update", data)
    req.Header = headers

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

PUT /api/v1/partner/reseller/{reseller_id}/subscription/{external_subscription_id}/update

Updates Company Subscription

Body parameter

{
  "subscription": {
    "external_customer_id": "93c4e53b-9a16-4da4-919f-ab5412e532e4",
    "external_subscription_id": "8eea702c-f14c-4d2f-8c0c-0ff7b1813476",
    "plan_quantity": 10,
    "subscription_expiration_date": "2019-09-30T00:00:00Z",
    "subscription_plan": "starter",
    "subscription_status": "active",
    "trial_expiration_date": "2019-07-30T00:00:00Z"
  }
}

Parameters

Name	In	Type	Required	Description
reseller_id	path	string	true	Reseller ID
external_subscription_id	path	string	true	Subscription ID in reseller systems
body	body	ResellerSubscriptionData	false	Subscription Data

Example responses

400 Response

{
  "errors": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	OK	None
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Register

Register Company

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/register/company \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/register/company HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/register/company', headers = headers)

print(r.json())

const inputBody = '{
  "company": {
    "address": "14138 Cummerata Brooks",
    "admin_user_email": "company-admin-0@example.com",
    "billing_email": "billing-1@example.com",
    "city": "Ritchieberg",
    "codice_destinatario": "000000",
    "country": "Lithuania",
    "fiscal_code": "ABCDEF12A01H501-1",
    "lead_source": "direct-website",
    "location_info": {
      "lat": "43",
      "long": "0"
    },
    "name": "Marks-Kemmer",
    "number_of_employees": 20,
    "pec": "foo.bar@pec.it",
    "phone": "07881 836703",
    "plan_quantity": 10,
    "preferences": {
      "stamping_enabled": "true"
    },
    "province": "TO",
    "referral_code": "123",
    "subscription_plan": "started",
    "timezone": "Europe/Rome",
    "vat": "123456789-0",
    "zip": "92328"
  },
  "user": {
    "account_type": "personal",
    "address": "1265 Prohaska Neck",
    "birthdate": "1980-08-22",
    "city": "Port Clemmieport",
    "company_ids": [
      "8583e291-4720-4983-a483-95f0bd1b3cbd",
      "04c7307b-4bb7-4dce-9e73-40b189c84ba1"
    ],
    "contract_ids": [
      "f3178dc6-f69a-4526-b99e-f8ea7a724a44",
      "c16080e6-120e-4822-be64-a7c9bed120e2"
    ],
    "country": "Jordan",
    "email": "user-0@example.com",
    "emergency_contact_info": "friend",
    "emergency_contact_name": "Mozell Padberg",
    "emergency_contact_phone": "(286) 446-6696",
    "firstname": "Raymundo",
    "fiscal_code": "otDN27hMtWIhRyN8",
    "gender": "m",
    "iban": "PK39MUJLJB72LKAYW5CDWL3M",
    "lastname": "Sauer",
    "lead_source": "SITE",
    "location_info": {},
    "nationality": "Guam",
    "other_contacts": {
      "skype": "skype.id"
    },
    "personal_email": "user-1@example.com",
    "personal_phone": "832-248-4710",
    "place_of_birth": "Winnifredstad",
    "preferences": {
      "date_format": "DD/MM/YYYY"
    },
    "province": "Mississippi",
    "team_ids": [
      "e0bdb54b-aad3-4e23-bf04-9c315b6669dc",
      "ae0b6606-78fb-4281-ab37-eb84d4db8b65",
      "924083ad-a0b8-4c69-84f2-b41f7a971a7b",
      "3b646796-0df1-4275-96b7-bbfec112d9a0"
    ],
    "zip": "14801"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/register/company',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/register/company', 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/register/company");
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/register/company", data)
    req.Header = headers

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

POST /api/v1/register/company

Creates a company and its admin user

Body parameter

{
  "company": {
    "address": "14138 Cummerata Brooks",
    "admin_user_email": "company-admin-0@example.com",
    "billing_email": "billing-1@example.com",
    "city": "Ritchieberg",
    "codice_destinatario": "000000",
    "country": "Lithuania",
    "fiscal_code": "ABCDEF12A01H501-1",
    "lead_source": "direct-website",
    "location_info": {
      "lat": "43",
      "long": "0"
    },
    "name": "Marks-Kemmer",
    "number_of_employees": 20,
    "pec": "foo.bar@pec.it",
    "phone": "07881 836703",
    "plan_quantity": 10,
    "preferences": {
      "stamping_enabled": "true"
    },
    "province": "TO",
    "referral_code": "123",
    "subscription_plan": "started",
    "timezone": "Europe/Rome",
    "vat": "123456789-0",
    "zip": "92328"
  },
  "user": {
    "account_type": "personal",
    "address": "1265 Prohaska Neck",
    "birthdate": "1980-08-22",
    "city": "Port Clemmieport",
    "company_ids": [
      "8583e291-4720-4983-a483-95f0bd1b3cbd",
      "04c7307b-4bb7-4dce-9e73-40b189c84ba1"
    ],
    "contract_ids": [
      "f3178dc6-f69a-4526-b99e-f8ea7a724a44",
      "c16080e6-120e-4822-be64-a7c9bed120e2"
    ],
    "country": "Jordan",
    "email": "user-0@example.com",
    "emergency_contact_info": "friend",
    "emergency_contact_name": "Mozell Padberg",
    "emergency_contact_phone": "(286) 446-6696",
    "firstname": "Raymundo",
    "fiscal_code": "otDN27hMtWIhRyN8",
    "gender": "m",
    "iban": "PK39MUJLJB72LKAYW5CDWL3M",
    "lastname": "Sauer",
    "lead_source": "SITE",
    "location_info": {},
    "nationality": "Guam",
    "other_contacts": {
      "skype": "skype.id"
    },
    "personal_email": "user-1@example.com",
    "personal_phone": "832-248-4710",
    "place_of_birth": "Winnifredstad",
    "preferences": {
      "date_format": "DD/MM/YYYY"
    },
    "province": "Mississippi",
    "team_ids": [
      "e0bdb54b-aad3-4e23-bf04-9c315b6669dc",
      "ae0b6606-78fb-4281-ab37-eb84d4db8b65",
      "924083ad-a0b8-4c69-84f2-b41f7a971a7b",
      "3b646796-0df1-4275-96b7-bbfec112d9a0"
    ],
    "zip": "14801"
  }
}

Parameters

Name	In	Type	Required	Description
body	body	CompanyRegistrationParams	false	registration attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Report

Company Mismatches Count

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/reports/companies/{company_id}/mismatches/count \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/reports/companies/{company_id}/mismatches/count HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/reports/companies/{company_id}/mismatches/count', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/reports/companies/{company_id}/mismatches/count',
{
  method: 'GET',

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

<?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/reports/companies/{company_id}/mismatches/count', 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/reports/companies/{company_id}/mismatches/count");
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/reports/companies/{company_id}/mismatches/count", data)
    req.Header = headers

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

GET /api/v1/reports/companies/{company_id}/mismatches/count

Renders a list of contracts with mismatches count

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
from_date	query	string	false	Start date
to_date	query	string	false	End date
team_ids	query	array[string]	false	Team Ids
subsidiary_ids	query	array[string]	false	Subsidiary Ids
page	query	integer	false	Page
page_size	query	integer	false	Page Size

Example responses

200 Response

{
  "entries": [
    {
      "contract_id": "string",
      "firstname": "string",
      "lastname": "string",
      "mismatches": 0,
      "user_id": "string"
    }
  ],
  "page": 0,
  "page_size": 0,
  "total_entries": 0,
  "total_pages": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	CompanyMismatchEntries

Company Presences Summary

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/reports/companies/{company_id}/presences/summary \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/reports/companies/{company_id}/presences/summary HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/reports/companies/{company_id}/presences/summary', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/reports/companies/{company_id}/presences/summary',
{
  method: 'GET',

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

<?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/reports/companies/{company_id}/presences/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/reports/companies/{company_id}/presences/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/reports/companies/{company_id}/presences/summary", data)
    req.Header = headers

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

GET /api/v1/reports/companies/{company_id}/presences/summary

Renders a list of contracts with presences summary

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
from_date	query	string	false	Start date
to_date	query	string	false	End date
team_ids	query	array[string]	false	Team Ids
subsidiary_ids	query	array[string]	false	Subsidiary Ids
page	query	integer	false	Page
page_size	query	integer	false	Page Size

Example responses

200 Response

{
  "entries": [
    {
      "absences": 0,
      "additives": 0,
      "contract_id": "string",
      "firstname": "string",
      "lastname": "string",
      "presences": 0,
      "user_id": "string"
    }
  ],
  "page": 0,
  "page_size": 0,
  "total_entries": 0,
  "total_pages": 0
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	CompanyPresencesSummaryEntries

List contract mismatches

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/reports/contracts/{contract_id}/mismatches \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/reports/contracts/{contract_id}/mismatches HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/reports/contracts/{contract_id}/mismatches', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/reports/contracts/{contract_id}/mismatches',
{
  method: 'GET',

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

<?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/reports/contracts/{contract_id}/mismatches', 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/reports/contracts/{contract_id}/mismatches");
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/reports/contracts/{contract_id}/mismatches", data)
    req.Header = headers

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

GET /api/v1/reports/contracts/{contract_id}/mismatches

Renders a list of mismatches by contract

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
from_date	query	string	false	Start date
to_date	query	string	false	End date

Example responses

200 Response

[
  {
    "actual_presence": 0,
    "duration": 960,
    "is_on_interval": false,
    "scheduled_presence": 960,
    "type": "mismatched_absence"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractMismatchEntries

Contract Presences Summary

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/reports/contracts/{contract_id}/presences/summary \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/reports/contracts/{contract_id}/presences/summary HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/reports/contracts/{contract_id}/presences/summary', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/reports/contracts/{contract_id}/presences/summary',
{
  method: 'GET',

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

<?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/reports/contracts/{contract_id}/presences/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/reports/contracts/{contract_id}/presences/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/reports/contracts/{contract_id}/presences/summary", data)
    req.Header = headers

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

GET /api/v1/reports/contracts/{contract_id}/presences/summary

Renders the summary of a contract's presence

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
from_date	query	string	false	Start date
to_date	query	string	false	End date

Example responses

200 Response

[
  {
    "absences": {
      "details": [
        {
          "additive": true,
          "duration": 60,
          "presence": true,
          "type_label": "extra",
          "type_name": "extra"
        }
      ],
      "duration": 480
    },
    "additives": {
      "details": [
        {
          "additive": true,
          "duration": 60,
          "presence": true,
          "type_label": "extra",
          "type_name": "extra"
        }
      ],
      "duration": 480
    },
    "contract_id": "string",
    "mismatches": {
      "details": [
        {
          "additive": true,
          "duration": 60,
          "presence": true,
          "type_label": "extra",
          "type_name": "extra"
        }
      ],
      "duration": 480
    },
    "presences": {
      "details": [
        {
          "additive": true,
          "duration": 60,
          "presence": true,
          "type_label": "extra",
          "type_name": "extra"
        }
      ],
      "duration": 480
    }
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractPresencesSummaryEntries

Request

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

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())

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);
});

<?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

[
  {
    "contract_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
    "entity_data": {
      "approvers_ids": [
        "13d2371a-326d-4b96-912f-c20f2c2cef15"
      ],
      "contract_id": "90725746-5c2d-44fc-908f-96e50f8e65ba",
      "followers_ids": [
        "c1f86232-2dfb-42a5-aff0-65521a3a01ac",
        "e80ee330-aa3a-4f8d-be8f-748869705b5d"
      ],
      "from_date": "2019-02-26",
      "from_time": "10:00:00",
      "id": "e508bd7c-aa20-4cfc-a179-e2324b416e29",
      "notes": "Quisquam atque impedit accusantium consequatur sint distinctio aut est explicabo.",
      "status": "requested",
      "to_date": "2019-03-02",
      "to_time": "12:00:00",
      "type_id": "holiday",
      "type_label": "quia",
      "type_name": "adipisci"
    },
    "entity_id": "ddbb23bb-1cbe-48ce-bd55-43908e623e1f",
    "entity_type": "justification",
    "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Requests

Renders a list of requests for a contract

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/requests/{company_id}/by_contract/{contract_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/requests/{company_id}/by_contract/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/requests/{company_id}/by_contract/{contract_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/requests/{company_id}/by_contract/{contract_id}',
{
  method: 'GET',

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

<?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_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}/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}/by_contract/{contract_id}", data)
    req.Header = headers

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

GET /api/v1/requests/{company_id}/by_contract/{contract_id}

Renders a list of requests for a contract...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
contract_id	path	string	true	contract id

Example responses

200 Response

[
  {
    "contract_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
    "entity_data": {
      "approvers_ids": [
        "13d2371a-326d-4b96-912f-c20f2c2cef15"
      ],
      "contract_id": "90725746-5c2d-44fc-908f-96e50f8e65ba",
      "followers_ids": [
        "c1f86232-2dfb-42a5-aff0-65521a3a01ac",
        "e80ee330-aa3a-4f8d-be8f-748869705b5d"
      ],
      "from_date": "2019-02-26",
      "from_time": "10:00:00",
      "id": "e508bd7c-aa20-4cfc-a179-e2324b416e29",
      "notes": "Quisquam atque impedit accusantium consequatur sint distinctio aut est explicabo.",
      "status": "requested",
      "to_date": "2019-03-02",
      "to_time": "12:00:00",
      "type_id": "holiday",
      "type_label": "quia",
      "type_name": "adipisci"
    },
    "entity_id": "ddbb23bb-1cbe-48ce-bd55-43908e623e1f",
    "entity_type": "justification",
    "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Requests

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

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())

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);
});

<?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": [
    "6cadbf6b-b4a5-43a4-86ff-cc330e1e01ca"
  ]
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Approvers

Renders a set of approvers by entity

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

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_entity/{entity_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_id}',
{
  method: 'GET',

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

<?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_entity/{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}/approvers/by_entity/{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}/approvers/by_entity/{entity_id}", data)
    req.Header = headers

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

GET /api/v1/requests/{company_id}/{entity_type}/approvers/by_entity/{entity_id}

Renders a set of approvers 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

{
  "approver_ids": [
    "6cadbf6b-b4a5-43a4-86ff-cc330e1e01ca"
  ]
}

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

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())

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);
});

<?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

{
  "contract_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
  "entity_data": {
    "approvers_ids": [
      "13d2371a-326d-4b96-912f-c20f2c2cef15"
    ],
    "contract_id": "90725746-5c2d-44fc-908f-96e50f8e65ba",
    "followers_ids": [
      "c1f86232-2dfb-42a5-aff0-65521a3a01ac",
      "e80ee330-aa3a-4f8d-be8f-748869705b5d"
    ],
    "from_date": "2019-02-26",
    "from_time": "10:00:00",
    "id": "e508bd7c-aa20-4cfc-a179-e2324b416e29",
    "notes": "Quisquam atque impedit accusantium consequatur sint distinctio aut est explicabo.",
    "status": "requested",
    "to_date": "2019-03-02",
    "to_time": "12:00:00",
    "type_id": "holiday",
    "type_label": "quia",
    "type_name": "adipisci"
  },
  "entity_id": "ddbb23bb-1cbe-48ce-bd55-43908e623e1f",
  "entity_type": "justification",
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Request

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

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())

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);
});

<?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)
    // ...
}

GET /api/v1/requests/{company_id}/{id}

Renders a request...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	request id

Example responses

200 Response

{
  "contract_id": "eb05b57b-2eab-4e53-9ccd-337f3f87b7d2",
  "entity_data": {
    "approvers_ids": [
      "13d2371a-326d-4b96-912f-c20f2c2cef15"
    ],
    "contract_id": "90725746-5c2d-44fc-908f-96e50f8e65ba",
    "followers_ids": [
      "c1f86232-2dfb-42a5-aff0-65521a3a01ac",
      "e80ee330-aa3a-4f8d-be8f-748869705b5d"
    ],
    "from_date": "2019-02-26",
    "from_time": "10:00:00",
    "id": "e508bd7c-aa20-4cfc-a179-e2324b416e29",
    "notes": "Quisquam atque impedit accusantium consequatur sint distinctio aut est explicabo.",
    "status": "requested",
    "to_date": "2019-03-02",
    "to_time": "12:00:00",
    "type_id": "holiday",
    "type_label": "quia",
    "type_name": "adipisci"
  },
  "entity_id": "ddbb23bb-1cbe-48ce-bd55-43908e623e1f",
  "entity_type": "justification",
  "id": "67acc8e0-b5f2-416c-9678-9cb89fda633f"
}

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: */*

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())

const inputBody = '{
  "approver_contract_id": "07e0fcb3-c329-42a9-b0f9-4c5216852911",
  "notes": "Some notes about request update"
}';
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);
});

<?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

{
  "approver_contract_id": "07e0fcb3-c329-42a9-b0f9-4c5216852911",
  "notes": "Some notes about request update"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	request id
body	body	UpdateRequestStatus	false	approve request attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Rejects a request

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/requests/{id}/reject \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/requests/{id}/reject HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/requests/{id}/reject', headers = headers)

print(r.json())

const inputBody = '{
  "approver_contract_id": "07e0fcb3-c329-42a9-b0f9-4c5216852911",
  "notes": "Some notes about request update"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/requests/{id}/reject',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/requests/{id}/reject', 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}/reject");
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/requests/{id}/reject", data)
    req.Header = headers

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

PUT /api/v1/requests/{id}/reject

Rejects a request...

Body parameter

{
  "approver_contract_id": "07e0fcb3-c329-42a9-b0f9-4c5216852911",
  "notes": "Some notes about request update"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	Request ID
body	body	UpdateRequestStatus	false	Reject request attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Schedule

Renders a list of daily schedules for a company

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/schedules/daily/company/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/schedules/daily/company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/schedules/daily/company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/daily/company/{company_id}',
{
  method: 'GET',

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

<?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/schedules/daily/company/{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/schedules/daily/company/{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/schedules/daily/company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/schedules/daily/company/{company_id}

Renders a list of daily schedules for a company...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
name	query	string	false	daily schedule name

Example responses

200 Response

[
  {
    "company_id": "98a763df-53b3-43bf-a687-2f55a6fc0bed",
    "computed_name": "1h 40m",
    "id": "471e6d66-2f53-45b9-8f30-654f873bedcc",
    "name": "Turno Standard",
    "note": "note",
    "schedule": [
      {
        "end": "13:00:00",
        "start": "09:00:00"
      },
      {
        "end": "18:00:00",
        "start": "14:00:00"
      }
    ],
    "shift_code_name": "MT"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	DailySchedules

Adds a new daily schedule to a company

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/schedules/daily/company/{company_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/schedules/daily/company/{company_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/schedules/daily/company/{company_id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "98a763df-53b3-43bf-a687-2f55a6fc0bed",
  "computed_name": "1h 40m",
  "id": "471e6d66-2f53-45b9-8f30-654f873bedcc",
  "name": "Turno Standard",
  "note": "note",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "shift_code_name": "MT"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/daily/company/{company_id}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/schedules/daily/company/{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/schedules/daily/company/{company_id}");
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/schedules/daily/company/{company_id}", data)
    req.Header = headers

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

POST /api/v1/schedules/daily/company/{company_id}

Adds a new daily schedule to a company...

Body parameter

{
  "company_id": "98a763df-53b3-43bf-a687-2f55a6fc0bed",
  "computed_name": "1h 40m",
  "id": "471e6d66-2f53-45b9-8f30-654f873bedcc",
  "name": "Turno Standard",
  "note": "note",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "shift_code_name": "MT"
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
body	body	DailySchedule	false	schedule attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Retrieves a daily schedule given its schedule

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/by_schedule \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/by_schedule HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/by_schedule', headers = headers)

print(r.json())

const inputBody = '{
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/by_schedule',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/schedules/daily/company/{company_id}/by_schedule', 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/schedules/daily/company/{company_id}/by_schedule");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/by_schedule", data)
    req.Header = headers

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

POST /api/v1/schedules/daily/company/{company_id}/by_schedule

Retrieves a daily schedule given its schedule...

Body parameter

{
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    }
  ]
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
body	body	object	false	Request body
» schedule	body	[ScheduleItem]	false	schedule content
»» ScheduleItem	body	ScheduleItem	false	A ScheduleItem
»»» _end	body	string	true	ISO-8601 formatted time
»»» start	body	string	true	ISO-8601 formatted time

Example responses

200 Response

{
  "company_id": "98a763df-53b3-43bf-a687-2f55a6fc0bed",
  "computed_name": "1h 40m",
  "id": "471e6d66-2f53-45b9-8f30-654f873bedcc",
  "name": "Turno Standard",
  "note": "note",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "shift_code_name": "MT"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	DailySchedule

Deletes a company daily schedule

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/{id}',
{
  method: 'DELETE',

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

<?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/schedules/daily/company/{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/schedules/daily/company/{company_id}/{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/schedules/daily/company/{company_id}/{id}", data)
    req.Header = headers

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

DELETE /api/v1/schedules/daily/company/{company_id}/{id}

Deletes a company daily schedule...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	schedule id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Updates a company daily schedule

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "98a763df-53b3-43bf-a687-2f55a6fc0bed",
  "computed_name": "1h 40m",
  "id": "471e6d66-2f53-45b9-8f30-654f873bedcc",
  "name": "Turno Standard",
  "note": "note",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "shift_code_name": "MT"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/daily/company/{company_id}/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/schedules/daily/company/{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/schedules/daily/company/{company_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/schedules/daily/company/{company_id}/{id}", data)
    req.Header = headers

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

PUT /api/v1/schedules/daily/company/{company_id}/{id}

Updates a company daily schedule...

Body parameter

{
  "company_id": "98a763df-53b3-43bf-a687-2f55a6fc0bed",
  "computed_name": "1h 40m",
  "id": "471e6d66-2f53-45b9-8f30-654f873bedcc",
  "name": "Turno Standard",
  "note": "note",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "shift_code_name": "MT"
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	schedule id
body	body	DailySchedule	false	schedule attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders the schedule for a contract

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id}',
{
  method: 'GET',

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

<?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/schedules/daily/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/schedules/daily/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/schedules/daily/contract/{contract_id}", data)
    req.Header = headers

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

GET /api/v1/schedules/daily/contract/{contract_id}

Renders the schedule for a contract...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id

Example responses

200 Response

{
  "active": true,
  "company_id": "50c1ee58-91c2-4c04-a8b9-ed6ed0de7368",
  "contract_id": "aec61a8b-ec14-4969-bd5e-591fdd5b16b1",
  "id": "b326aced-250c-4364-af42-f3c41018c44f",
  "subsidiary_id": "b1238b08-b455-4f28-82b6-de386e043286",
  "team_ids": [
    "01fa463a-cc7e-43a0-adfb-b6eaf0f0ad19"
  ],
  "user_id": "eb79f4dd-dbd1-4e2e-b234-270edb475f14",
  "weekly_schedule_id": "04329eed-db96-44a4-a0ca-f68d9fc5bfa4"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractSchedule

Renders the day schedule for a contract

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id}/day?date=2019-08-24 \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id}/day?date=2019-08-24 HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id}/day', params={
  'date': '2019-08-24'
}, headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id}/day?date=2019-08-24',
{
  method: 'GET',

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

<?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/schedules/daily/contract/{contract_id}/day', 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/schedules/daily/contract/{contract_id}/day?date=2019-08-24");
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/schedules/daily/contract/{contract_id}/day", data)
    req.Header = headers

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

GET /api/v1/schedules/daily/contract/{contract_id}/day

Renders the day schedule for a contract...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
date	query	string(date)	true	date

Example responses

200 Response

{
  "active": true,
  "company_id": "50c1ee58-91c2-4c04-a8b9-ed6ed0de7368",
  "contract_id": "aec61a8b-ec14-4969-bd5e-591fdd5b16b1",
  "id": "b326aced-250c-4364-af42-f3c41018c44f",
  "subsidiary_id": "b1238b08-b455-4f28-82b6-de386e043286",
  "team_ids": [
    "01fa463a-cc7e-43a0-adfb-b6eaf0f0ad19"
  ],
  "user_id": "eb79f4dd-dbd1-4e2e-b234-270edb475f14",
  "weekly_schedule_id": "04329eed-db96-44a4-a0ca-f68d9fc5bfa4"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractSchedule

Renders the contract schedule override for a date

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id}/{date} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id}/{date} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id}/{date}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/daily/contract/{contract_id}/{date}',
{
  method: 'GET',

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

<?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/schedules/daily/contract/{contract_id}/{date}', 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/schedules/daily/contract/{contract_id}/{date}");
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/schedules/daily/contract/{contract_id}/{date}", data)
    req.Header = headers

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

GET /api/v1/schedules/daily/contract/{contract_id}/{date}

Renders the contract schedule override for a date...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
date	path	string(date)	true	schedule date

Example responses

200 Response

{
  "contract_id": "ac04ac09-83ee-44f6-af95-31ced1367198",
  "daily_schedule_id": "c51715de-ea7f-4c37-b3c1-36c86224d54e",
  "date": "2019-02-25",
  "id": "ed8bba37-77c6-468f-98d7-47c2a7fa1127"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractDailySchedule

Renders a list of weekly schedules for a company

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/schedules/weekly/company/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/schedules/weekly/company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}',
{
  method: 'GET',

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

<?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/schedules/weekly/company/{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/schedules/weekly/company/{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/schedules/weekly/company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/schedules/weekly/company/{company_id}

Renders a list of weekly schedules for a company...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id

Example responses

200 Response

[
  {
    "company_id": "8955a123-b10d-4a6b-9c2d-90de8486dd10",
    "fri": "726ee840-f36a-4128-aa65-f93f9484d455",
    "id": "bce1dea1-17a9-489f-875e-6ab5ee76ebcc",
    "mon": "a28b417a-8732-4c21-94ad-e6cf49ef0efd",
    "name": "Settimana Standard",
    "note": "note",
    "thu": "8389b99e-b0d2-4d84-8643-e1b484fdc3f8",
    "tue": "6de10b32-4a54-427b-b0d0-9efaea64f7ca",
    "wed": "9386582a-301e-4866-9455-c7c95b399f21",
    "weekly_minutes": 2400
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	WeeklySchedules

Adds a new weekly schedule to a company

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/schedules/weekly/company/{company_id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/schedules/weekly/company/{company_id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "8955a123-b10d-4a6b-9c2d-90de8486dd10",
  "fri": "726ee840-f36a-4128-aa65-f93f9484d455",
  "id": "bce1dea1-17a9-489f-875e-6ab5ee76ebcc",
  "mon": "a28b417a-8732-4c21-94ad-e6cf49ef0efd",
  "name": "Settimana Standard",
  "note": "note",
  "thu": "8389b99e-b0d2-4d84-8643-e1b484fdc3f8",
  "tue": "6de10b32-4a54-427b-b0d0-9efaea64f7ca",
  "wed": "9386582a-301e-4866-9455-c7c95b399f21",
  "weekly_minutes": 2400
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/schedules/weekly/company/{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/schedules/weekly/company/{company_id}");
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/schedules/weekly/company/{company_id}", data)
    req.Header = headers

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

POST /api/v1/schedules/weekly/company/{company_id}

Adds a new weekly schedule to a company...

Body parameter

{
  "company_id": "8955a123-b10d-4a6b-9c2d-90de8486dd10",
  "fri": "726ee840-f36a-4128-aa65-f93f9484d455",
  "id": "bce1dea1-17a9-489f-875e-6ab5ee76ebcc",
  "mon": "a28b417a-8732-4c21-94ad-e6cf49ef0efd",
  "name": "Settimana Standard",
  "note": "note",
  "thu": "8389b99e-b0d2-4d84-8643-e1b484fdc3f8",
  "tue": "6de10b32-4a54-427b-b0d0-9efaea64f7ca",
  "wed": "9386582a-301e-4866-9455-c7c95b399f21",
  "weekly_minutes": 2400
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
body	body	WeeklySchedule	false	schedule attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Retrieves a weekly schedule given its schedule

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/by_schedule \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/by_schedule HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: application/json

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/by_schedule', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "8955a123-b10d-4a6b-9c2d-90de8486dd10",
  "fri": "726ee840-f36a-4128-aa65-f93f9484d455",
  "id": "bce1dea1-17a9-489f-875e-6ab5ee76ebcc",
  "mon": "a28b417a-8732-4c21-94ad-e6cf49ef0efd",
  "name": "Settimana Standard",
  "note": "note",
  "thu": "8389b99e-b0d2-4d84-8643-e1b484fdc3f8",
  "tue": "6de10b32-4a54-427b-b0d0-9efaea64f7ca",
  "wed": "9386582a-301e-4866-9455-c7c95b399f21",
  "weekly_minutes": 2400
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/by_schedule',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    '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/schedules/weekly/company/{company_id}/by_schedule', 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/schedules/weekly/company/{company_id}/by_schedule");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/by_schedule", data)
    req.Header = headers

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

POST /api/v1/schedules/weekly/company/{company_id}/by_schedule

Retrieves a weekly schedule given its schedule...

Body parameter

{
  "company_id": "8955a123-b10d-4a6b-9c2d-90de8486dd10",
  "fri": "726ee840-f36a-4128-aa65-f93f9484d455",
  "id": "bce1dea1-17a9-489f-875e-6ab5ee76ebcc",
  "mon": "a28b417a-8732-4c21-94ad-e6cf49ef0efd",
  "name": "Settimana Standard",
  "note": "note",
  "thu": "8389b99e-b0d2-4d84-8643-e1b484fdc3f8",
  "tue": "6de10b32-4a54-427b-b0d0-9efaea64f7ca",
  "wed": "9386582a-301e-4866-9455-c7c95b399f21",
  "weekly_minutes": 2400
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
body	body	WeeklySchedule	true	schedule map

Example responses

200 Response

{
  "company_id": "8955a123-b10d-4a6b-9c2d-90de8486dd10",
  "fri": "726ee840-f36a-4128-aa65-f93f9484d455",
  "id": "bce1dea1-17a9-489f-875e-6ab5ee76ebcc",
  "mon": "a28b417a-8732-4c21-94ad-e6cf49ef0efd",
  "name": "Settimana Standard",
  "note": "note",
  "thu": "8389b99e-b0d2-4d84-8643-e1b484fdc3f8",
  "tue": "6de10b32-4a54-427b-b0d0-9efaea64f7ca",
  "wed": "9386582a-301e-4866-9455-c7c95b399f21",
  "weekly_minutes": 2400
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	WeeklySchedule

Deletes a company weekly schedule

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/{id}',
{
  method: 'DELETE',

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

<?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/schedules/weekly/company/{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/schedules/weekly/company/{company_id}/{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/schedules/weekly/company/{company_id}/{id}", data)
    req.Header = headers

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

DELETE /api/v1/schedules/weekly/company/{company_id}/{id}

Deletes a company weekly schedule...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	schedule id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Updates a company weekly schedule

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "8955a123-b10d-4a6b-9c2d-90de8486dd10",
  "fri": "726ee840-f36a-4128-aa65-f93f9484d455",
  "id": "bce1dea1-17a9-489f-875e-6ab5ee76ebcc",
  "mon": "a28b417a-8732-4c21-94ad-e6cf49ef0efd",
  "name": "Settimana Standard",
  "note": "note",
  "thu": "8389b99e-b0d2-4d84-8643-e1b484fdc3f8",
  "tue": "6de10b32-4a54-427b-b0d0-9efaea64f7ca",
  "wed": "9386582a-301e-4866-9455-c7c95b399f21",
  "weekly_minutes": 2400
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/weekly/company/{company_id}/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/schedules/weekly/company/{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/schedules/weekly/company/{company_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/schedules/weekly/company/{company_id}/{id}", data)
    req.Header = headers

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

PUT /api/v1/schedules/weekly/company/{company_id}/{id}

Updates a company weekly schedule...

Body parameter

{
  "company_id": "8955a123-b10d-4a6b-9c2d-90de8486dd10",
  "fri": "726ee840-f36a-4128-aa65-f93f9484d455",
  "id": "bce1dea1-17a9-489f-875e-6ab5ee76ebcc",
  "mon": "a28b417a-8732-4c21-94ad-e6cf49ef0efd",
  "name": "Settimana Standard",
  "note": "note",
  "thu": "8389b99e-b0d2-4d84-8643-e1b484fdc3f8",
  "tue": "6de10b32-4a54-427b-b0d0-9efaea64f7ca",
  "wed": "9386582a-301e-4866-9455-c7c95b399f21",
  "weekly_minutes": 2400
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	schedule id
body	body	WeeklySchedule	false	schedule attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of weekly schedule overrides for a contract

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id}',
{
  method: 'GET',

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

<?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/schedules/weekly/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/schedules/weekly/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/schedules/weekly/contract/{contract_id}", data)
    req.Header = headers

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

GET /api/v1/schedules/weekly/contract/{contract_id}

Renders a list of weekly schedule overrides for a contract...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id

Example responses

200 Response

[
  {
    "company_id": "8955a123-b10d-4a6b-9c2d-90de8486dd10",
    "fri": "726ee840-f36a-4128-aa65-f93f9484d455",
    "id": "bce1dea1-17a9-489f-875e-6ab5ee76ebcc",
    "mon": "a28b417a-8732-4c21-94ad-e6cf49ef0efd",
    "name": "Settimana Standard",
    "note": "note",
    "thu": "8389b99e-b0d2-4d84-8643-e1b484fdc3f8",
    "tue": "6de10b32-4a54-427b-b0d0-9efaea64f7ca",
    "wed": "9386582a-301e-4866-9455-c7c95b399f21",
    "weekly_minutes": 2400
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	WeeklySchedules

Renders a list of weekly schedules for a contract

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id}/by_date?from_date=string&to_date=string \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id}/by_date?from_date=string&to_date=string HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id}/by_date', params={
  'from_date': 'string',  'to_date': 'string'
}, headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id}/by_date?from_date=string&to_date=string',
{
  method: 'GET',

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

<?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/schedules/weekly/contract/{contract_id}/by_date', 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/schedules/weekly/contract/{contract_id}/by_date?from_date=string&to_date=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id}/by_date", data)
    req.Header = headers

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

GET /api/v1/schedules/weekly/contract/{contract_id}/by_date

enders a list of weekly schedules for a contract in a given date range...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
from_date	query	string	true	ISO-8601 formatted from date
to_date	query	string	true	ISO-8601 formatted from date

Example responses

200 Response

[
  {
    "company_id": "da2a9710-ff49-46ca-abdd-59e91729eb39",
    "entries": [
      {
        "computed_name": "1h 40m",
        "day": "2024-07-15",
        "id": "ee6e41d3-c085-411b-9c36-24f055529b83",
        "name": "Turno Standard",
        "note": "note",
        "schedule": [
          {
            "duration": 100
          }
        ],
        "shift_code_name": "MT"
      }
    ],
    "from_date": "2024-07-15",
    "id": "f6f90422-cd30-471e-bd82-cb98b49a4c9f",
    "name": "name",
    "note": "note",
    "override_id": "d98ffa32-b4c8-4133-9b03-08edb8bbbc6d",
    "override_type": "cyclic",
    "to_date": "2024-07-15",
    "weekly_minutes": 2400
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	WeeklySchedulesSummary

Renders the contract schedule override for a week

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id}/{year}/{week_iso_number} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id}/{year}/{week_iso_number} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id}/{year}/{week_iso_number}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/weekly/contract/{contract_id}/{year}/{week_iso_number}',
{
  method: 'GET',

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

<?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/schedules/weekly/contract/{contract_id}/{year}/{week_iso_number}', 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/schedules/weekly/contract/{contract_id}/{year}/{week_iso_number}");
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/schedules/weekly/contract/{contract_id}/{year}/{week_iso_number}", data)
    req.Header = headers

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

GET /api/v1/schedules/weekly/contract/{contract_id}/{year}/{week_iso_number}

Renders the contract schedule override for a week...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
year	path	string	true	schedule year
week_iso_number	path	string	true	schedule week_iso_number

Example responses

200 Response

{
  "contract_id": "0dfeb3a1-bc46-4d01-8cdf-fb2e1e93d1fa",
  "id": "f792bf85-96ed-4100-8e2e-6107eee4794c",
  "week_iso_number": 34,
  "weekly_schedule_id": "35ba86f4-073c-4dba-b8c9-16e6ef3a1dc8",
  "year": 2018
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractWeeklySchedule

Adds Cyclic Schedule Override

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/schedules/{company_id}/cyclic_schedule_overrides \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/schedules/{company_id}/cyclic_schedule_overrides HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/schedules/{company_id}/cyclic_schedule_overrides', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "0fde97fa-cd96-46d3-9f77-660847887922",
  "contract_ids": [
    "0b3b7497-e9e1-4996-a81f-b0bd2f710845",
    "6c5c05ad-ff97-42c9-9365-13452d528ccd"
  ],
  "from_date": "2024-07-15",
  "schedule": [
    {
      "id": "c14b98ba-b1cf-4565-b3df-2ec7e8522e34",
      "index": 0
    },
    {
      "id": "b64481c8-4def-4957-9d33-a35682378101",
      "index": 1
    }
  ],
  "schedule_type": "weekly",
  "start_index": 0,
  "subsidiary_id": "8c07b0e8-8653-4ef0-8eb3-2ab5ead678a8",
  "to_date": "2024-07-15"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/{company_id}/cyclic_schedule_overrides',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/schedules/{company_id}/cyclic_schedule_overrides', 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/schedules/{company_id}/cyclic_schedule_overrides");
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/schedules/{company_id}/cyclic_schedule_overrides", data)
    req.Header = headers

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

POST /api/v1/schedules/{company_id}/cyclic_schedule_overrides

Adds a new Cyclic Schedule Override

Body parameter

{
  "company_id": "0fde97fa-cd96-46d3-9f77-660847887922",
  "contract_ids": [
    "0b3b7497-e9e1-4996-a81f-b0bd2f710845",
    "6c5c05ad-ff97-42c9-9365-13452d528ccd"
  ],
  "from_date": "2024-07-15",
  "schedule": [
    {
      "id": "c14b98ba-b1cf-4565-b3df-2ec7e8522e34",
      "index": 0
    },
    {
      "id": "b64481c8-4def-4957-9d33-a35682378101",
      "index": 1
    }
  ],
  "schedule_type": "weekly",
  "start_index": 0,
  "subsidiary_id": "8c07b0e8-8653-4ef0-8eb3-2ab5ead678a8",
  "to_date": "2024-07-15"
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
body	body	CyclicScheduleOverride	false	schedule change attributes

Example responses

400 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Adds Cyclic Schedule Override bulk

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/schedules/{company_id}/cyclic_schedule_overrides/bulk \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/schedules/{company_id}/cyclic_schedule_overrides/bulk HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/schedules/{company_id}/cyclic_schedule_overrides/bulk', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "24a67e9b-f67b-42da-b1e5-75c0c126a919",
  "contract_id": "90a5a727-b265-46be-87ad-5e99350c445a",
  "entries": [
    {
      "from_date": "2024-07-15",
      "to_date": "2024-07-15"
    },
    {
      "from_date": "2024-07-15",
      "to_date": "2024-07-15"
    }
  ],
  "shift_subsidiary_id": "63e945b6-55ef-469d-815c-0681b0e81a22",
  "weekly_schedule_id": "b0be77ea-0eb2-46c8-a70a-44d7440c9bdb"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/{company_id}/cyclic_schedule_overrides/bulk',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/schedules/{company_id}/cyclic_schedule_overrides/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/schedules/{company_id}/cyclic_schedule_overrides/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{
        "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/schedules/{company_id}/cyclic_schedule_overrides/bulk", data)
    req.Header = headers

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

POST /api/v1/schedules/{company_id}/cyclic_schedule_overrides/bulk

Adds a new Cyclic Schedule Override bulk

Body parameter

{
  "company_id": "24a67e9b-f67b-42da-b1e5-75c0c126a919",
  "contract_id": "90a5a727-b265-46be-87ad-5e99350c445a",
  "entries": [
    {
      "from_date": "2024-07-15",
      "to_date": "2024-07-15"
    },
    {
      "from_date": "2024-07-15",
      "to_date": "2024-07-15"
    }
  ],
  "shift_subsidiary_id": "63e945b6-55ef-469d-815c-0681b0e81a22",
  "weekly_schedule_id": "b0be77ea-0eb2-46c8-a70a-44d7440c9bdb"
}

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
body	body	BulkCyclicScheduleOverride	false	schedule change attributes

Example responses

400 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

List contract day schedule changes

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes',
{
  method: 'GET',

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

<?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/schedules/{contract_id}/day_schedule_changes', 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/schedules/{contract_id}/day_schedule_changes");
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/schedules/{contract_id}/day_schedule_changes", data)
    req.Header = headers

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

GET /api/v1/schedules/{contract_id}/day_schedule_changes

List contract day schedule changes

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractDayScheduleChanges
401	Unauthorized	Unauthorized	Unauthorized

Adds a new contract day schedule change

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "17fad1c8-89f7-4abf-9bc7-6b0d5b9f8e6d",
  "contract_id": "902aaecc-d32f-45c3-83d3-47ead703a1c5",
  "followers_ids": [],
  "from_date": "2024-07-15",
  "leaders_ids": [],
  "notes": "note",
  "requested_by": "5833b014-88e1-4e8f-bd66-6e4807556462",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "to_date": "2024-07-15"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/schedules/{contract_id}/day_schedule_changes', 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/schedules/{contract_id}/day_schedule_changes");
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/schedules/{contract_id}/day_schedule_changes", data)
    req.Header = headers

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

POST /api/v1/schedules/{contract_id}/day_schedule_changes

Adds a new contract day schedule change...

Body parameter

{
  "company_id": "17fad1c8-89f7-4abf-9bc7-6b0d5b9f8e6d",
  "contract_id": "902aaecc-d32f-45c3-83d3-47ead703a1c5",
  "followers_ids": [],
  "from_date": "2024-07-15",
  "leaders_ids": [],
  "notes": "note",
  "requested_by": "5833b014-88e1-4e8f-bd66-6e4807556462",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "to_date": "2024-07-15"
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
body	body	ContractDayScheduleChange	false	schedule change attributes

Example responses

400 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Adds a new contract day schedule change bulk

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/bulk \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/bulk HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/bulk', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "83514981-4ffb-4c22-882c-62f4a0c10f9e",
  "contract_id": "4eece372-da03-4564-88ff-a5a01c32d069",
  "entries": [
    {
      "from_date": "2024-07-15",
      "to_date": "2024-07-15"
    },
    {
      "from_date": "2024-07-15",
      "to_date": "2024-07-15"
    }
  ],
  "followers_ids": [],
  "leaders_ids": [],
  "notes": "note",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/bulk',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/schedules/{contract_id}/day_schedule_changes/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/schedules/{contract_id}/day_schedule_changes/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{
        "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/schedules/{contract_id}/day_schedule_changes/bulk", data)
    req.Header = headers

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

POST /api/v1/schedules/{contract_id}/day_schedule_changes/bulk

Adds a new contract day schedule change bulk...

Body parameter

{
  "company_id": "83514981-4ffb-4c22-882c-62f4a0c10f9e",
  "contract_id": "4eece372-da03-4564-88ff-a5a01c32d069",
  "entries": [
    {
      "from_date": "2024-07-15",
      "to_date": "2024-07-15"
    },
    {
      "from_date": "2024-07-15",
      "to_date": "2024-07-15"
    }
  ],
  "followers_ids": [],
  "leaders_ids": [],
  "notes": "note",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ]
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
body	body	ContractDayScheduleChangeBulk	false	schedule change attributes

Example responses

400 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Get contract day schedule change to be approved

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/date/{date} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/date/{date} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/date/{date}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/date/{date}',
{
  method: 'GET',

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

<?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/schedules/{contract_id}/day_schedule_changes/date/{date}', 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/schedules/{contract_id}/day_schedule_changes/date/{date}");
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/schedules/{contract_id}/day_schedule_changes/date/{date}", data)
    req.Header = headers

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

GET /api/v1/schedules/{contract_id}/day_schedule_changes/date/{date}

Get contract day schedule change to be approved by contract_id and date

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
date	path	string(date)	true	schedule date

Example responses

200 Response

{
  "company_id": "17fad1c8-89f7-4abf-9bc7-6b0d5b9f8e6d",
  "contract_id": "902aaecc-d32f-45c3-83d3-47ead703a1c5",
  "followers_ids": [],
  "from_date": "2024-07-15",
  "leaders_ids": [],
  "notes": "note",
  "requested_by": "5833b014-88e1-4e8f-bd66-6e4807556462",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "to_date": "2024-07-15"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractDayScheduleChange
401	Unauthorized	Unauthorized	Unauthorized

Requests cancellation of contract day schedule change

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id}',
{
  method: 'DELETE',

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

<?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/schedules/{contract_id}/day_schedule_changes/{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/schedules/{contract_id}/day_schedule_changes/{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/schedules/{contract_id}/day_schedule_changes/{id}", data)
    req.Header = headers

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

DELETE /api/v1/schedules/{contract_id}/day_schedule_changes/{id}

Requests cancellation of contract day schedule change...

Parameters

Name	In	Type	Required	Description
id	path	string	true	day schedule change 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 contract day schedule change

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id}',
{
  method: 'GET',

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

<?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/schedules/{contract_id}/day_schedule_changes/{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/schedules/{contract_id}/day_schedule_changes/{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/schedules/{contract_id}/day_schedule_changes/{id}", data)
    req.Header = headers

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

GET /api/v1/schedules/{contract_id}/day_schedule_changes/{id}

Get contract day schedule change

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
id	path	string	true	contract day schedule change id

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractDayScheduleChange
401	Unauthorized	Unauthorized	Unauthorized

Updates contract day schedule change

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "17fad1c8-89f7-4abf-9bc7-6b0d5b9f8e6d",
  "contract_id": "902aaecc-d32f-45c3-83d3-47ead703a1c5",
  "followers_ids": [],
  "from_date": "2024-07-15",
  "leaders_ids": [],
  "notes": "note",
  "requested_by": "5833b014-88e1-4e8f-bd66-6e4807556462",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "to_date": "2024-07-15"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/schedules/{contract_id}/day_schedule_changes/{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/schedules/{contract_id}/day_schedule_changes/{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/schedules/{contract_id}/day_schedule_changes/{id}", data)
    req.Header = headers

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

PUT /api/v1/schedules/{contract_id}/day_schedule_changes/{id}

Updates contract day schedule change...

Body parameter

{
  "company_id": "17fad1c8-89f7-4abf-9bc7-6b0d5b9f8e6d",
  "contract_id": "902aaecc-d32f-45c3-83d3-47ead703a1c5",
  "followers_ids": [],
  "from_date": "2024-07-15",
  "leaders_ids": [],
  "notes": "note",
  "requested_by": "5833b014-88e1-4e8f-bd66-6e4807556462",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "to_date": "2024-07-15"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	day schedule change id
contract_id	path	string	true	contract id
body	body	ContractDayScheduleChange	false	schedule change attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Adds a note to contract day schedule change

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id}/notes \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id}/notes HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id}/notes', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "17fad1c8-89f7-4abf-9bc7-6b0d5b9f8e6d",
  "contract_id": "902aaecc-d32f-45c3-83d3-47ead703a1c5",
  "followers_ids": [],
  "from_date": "2024-07-15",
  "leaders_ids": [],
  "notes": "note",
  "requested_by": "5833b014-88e1-4e8f-bd66-6e4807556462",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "to_date": "2024-07-15"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes/{id}/notes',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/schedules/{contract_id}/day_schedule_changes/{id}/notes', 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/schedules/{contract_id}/day_schedule_changes/{id}/notes");
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/schedules/{contract_id}/day_schedule_changes/{id}/notes", data)
    req.Header = headers

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

PUT /api/v1/schedules/{contract_id}/day_schedule_changes/{id}/notes

Adds a note to contract day schedule change...

Body parameter

{
  "company_id": "17fad1c8-89f7-4abf-9bc7-6b0d5b9f8e6d",
  "contract_id": "902aaecc-d32f-45c3-83d3-47ead703a1c5",
  "followers_ids": [],
  "from_date": "2024-07-15",
  "leaders_ids": [],
  "notes": "note",
  "requested_by": "5833b014-88e1-4e8f-bd66-6e4807556462",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "to_date": "2024-07-15"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	day schedule change id
contract_id	path	string	true	contract id
body	body	ContractDayScheduleChange	false	schedule change attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Adds a new contract day schedule change (syncronous)

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes_sync \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes_sync HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes_sync', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "17fad1c8-89f7-4abf-9bc7-6b0d5b9f8e6d",
  "contract_id": "902aaecc-d32f-45c3-83d3-47ead703a1c5",
  "followers_ids": [],
  "from_date": "2024-07-15",
  "leaders_ids": [],
  "notes": "note",
  "requested_by": "5833b014-88e1-4e8f-bd66-6e4807556462",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "to_date": "2024-07-15"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/schedules/{contract_id}/day_schedule_changes_sync',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/schedules/{contract_id}/day_schedule_changes_sync', 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/schedules/{contract_id}/day_schedule_changes_sync");
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/schedules/{contract_id}/day_schedule_changes_sync", data)
    req.Header = headers

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

POST /api/v1/schedules/{contract_id}/day_schedule_changes_sync

Adds a new contract day schedule change

Body parameter

{
  "company_id": "17fad1c8-89f7-4abf-9bc7-6b0d5b9f8e6d",
  "contract_id": "902aaecc-d32f-45c3-83d3-47ead703a1c5",
  "followers_ids": [],
  "from_date": "2024-07-15",
  "leaders_ids": [],
  "notes": "note",
  "requested_by": "5833b014-88e1-4e8f-bd66-6e4807556462",
  "schedule": [
    {
      "end": "13:00:00",
      "start": "09:00:00"
    },
    {
      "end": "18:00:00",
      "start": "14:00:00"
    }
  ],
  "to_date": "2024-07-15"
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
body	body	ContractDayScheduleChange	false	schedule change attributes

Example responses

200 Response

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractDayScheduleChange
400	Bad Request	Bad Request	BadRequest
401	Unauthorized	Unauthorized	Unauthorized
422	Unprocessable Entity	Unprocessable Entity	UnprocessableEntity

Stamping

Create stamping area

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/stampings/contracts/devices \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/stampings/contracts/devices HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/stampings/contracts/devices', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "4b5956fc-566e-478c-851f-c70616ddb669",
  "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
  "description": "Hotel & Lodging REITs",
  "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
  "device_info": {},
  "enabled": false,
  "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
  "name": "Fixed Line Telecommunications",
  "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/contracts/devices',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/stampings/contracts/devices', 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/stampings/contracts/devices");
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/stampings/contracts/devices", data)
    req.Header = headers

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

POST /api/v1/stampings/contracts/devices

Create stamping area...

Body parameter

{
  "company_id": "4b5956fc-566e-478c-851f-c70616ddb669",
  "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
  "description": "Hotel & Lodging REITs",
  "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
  "device_info": {},
  "enabled": false,
  "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
  "name": "Fixed Line Telecommunications",
  "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438"
}

Parameters

Name	In	Type	Required	Description
body	body	ContractDevice	false	contract device attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of stamping areas for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/areas/by_company/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/areas/by_company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/areas/by_company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/areas/by_company/{company_id}',
{
  method: 'GET',

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

<?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/stampings/areas/by_company/{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/stampings/areas/by_company/{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/stampings/areas/by_company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/areas/by_company/{company_id}

Renders a list of stamping areas for a given company id...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
subsidiary_id	query	string	false	subsidiary id

Example responses

200 Response

[
  {
    "additional_details": {},
    "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
    "contracts": [],
    "description": "Health Care Providers",
    "detached": false,
    "enabled": false,
    "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
    "lat": "17.57140909572334",
    "long": "69.22462284381567",
    "name": "Life Insurance",
    "radius": "50",
    "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	StampingAreas

Renders a list of stamping areas for a given contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/areas/by_contract/{contract_id}?company_id=string \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/areas/by_contract/{contract_id}?company_id=string HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/areas/by_contract/{contract_id}', params={
  'company_id': 'string'
}, headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/areas/by_contract/{contract_id}?company_id=string',
{
  method: 'GET',

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

<?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/stampings/areas/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/stampings/areas/by_contract/{contract_id}?company_id=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/stampings/areas/by_contract/{contract_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/areas/by_contract/{contract_id}

Renders a list of stamping areas for a given contract id...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
company_id	query	string	true	company id

Example responses

200 Response

[
  {
    "additional_details": {},
    "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
    "contracts": [],
    "description": "Health Care Providers",
    "detached": false,
    "enabled": false,
    "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
    "lat": "17.57140909572334",
    "long": "69.22462284381567",
    "name": "Life Insurance",
    "radius": "50",
    "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	StampingAreas

Updates chosen stamping area

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/areas/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/areas/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/stampings/areas/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "additional_details": {},
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "contracts": [],
  "description": "Health Care Providers",
  "detached": false,
  "enabled": false,
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "lat": "17.57140909572334",
  "long": "69.22462284381567",
  "name": "Life Insurance",
  "radius": "50",
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/areas/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/stampings/areas/{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/stampings/areas/{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/stampings/areas/{id}", data)
    req.Header = headers

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

PUT /api/v1/stampings/areas/{id}

Updates chosen stamping area...

Body parameter

{
  "additional_details": {},
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "contracts": [],
  "description": "Health Care Providers",
  "detached": false,
  "enabled": false,
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "lat": "17.57140909572334",
  "long": "69.22462284381567",
  "name": "Life Insurance",
  "radius": "50",
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	stamping area id
body	body	StampingArea	false	stamping area attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Updates chosen stamping area contracts

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/areas/{id}/contracts \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/areas/{id}/contracts HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/stampings/areas/{id}/contracts', headers = headers)

print(r.json())

const inputBody = '{
  "contract_ids": [
    "string"
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/areas/{id}/contracts',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/stampings/areas/{id}/contracts', 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/stampings/areas/{id}/contracts");
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/stampings/areas/{id}/contracts", data)
    req.Header = headers

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

PUT /api/v1/stampings/areas/{id}/contracts

Updates chosen stamping area contracts...

Body parameter

{
  "contract_ids": [
    "string"
  ]
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	stamping area id
body	body	StampingAreaContracts	false	stamping area attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Registers a beacon

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/stampings/beacons \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/stampings/beacons HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/stampings/beacons', headers = headers)

print(r.json())

const inputBody = '{
  "beacon_public_key": "string",
  "description": "string",
  "exponent": "string",
  "initial_clock": "string",
  "initial_eid": "string",
  "resolver_public_key": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/beacons',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/stampings/beacons', 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/stampings/beacons");
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/stampings/beacons", data)
    req.Header = headers

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

POST /api/v1/stampings/beacons

Registers a beacon...

Body parameter

{
  "beacon_public_key": "string",
  "description": "string",
  "exponent": "string",
  "initial_clock": "string",
  "initial_eid": "string",
  "resolver_public_key": "string"
}

Parameters

Name	In	Type	Required	Description
body	body	Beacon	false	beacon attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders eid params

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/beacons/eid/params \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/beacons/eid/params HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/beacons/eid/params', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/beacons/eid/params',
{
  method: 'GET',

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

<?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/stampings/beacons/eid/params', 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/stampings/beacons/eid/params");
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/stampings/beacons/eid/params", data)
    req.Header = headers

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

GET /api/v1/stampings/beacons/eid/params

Renders eid params...

Example responses

200 Response

{
  "max_exponent": "string",
  "min_exponent": "string",
  "public_key": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	EidParams

Renders a beacon

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/beacons/{eid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/beacons/{eid} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/beacons/{eid}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/beacons/{eid}',
{
  method: 'GET',

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

<?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/stampings/beacons/{eid}', 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/stampings/beacons/{eid}");
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/stampings/beacons/{eid}", data)
    req.Header = headers

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

GET /api/v1/stampings/beacons/{eid}

Renders a beacon...

Parameters

Name	In	Type	Required	Description
eid	path	string	true	eid

Example responses

200 Response

{
  "beacon_id": "string",
  "description": "string",
  "name": "string"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	BeaconId

Renders a list stamping entries for a given approver contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/by_approver/{approver_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/by_approver/{approver_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/by_approver/{approver_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/by_approver/{approver_id}',
{
  method: 'GET',

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

<?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/stampings/by_approver/{approver_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/stampings/by_approver/{approver_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/stampings/by_approver/{approver_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/by_approver/{approver_id}

Renders a list stamping entries for a given approver contract id...

Parameters

Name	In	Type	Required	Description
approver_id	path	string	true	approver id
start_date	query	string	false	Start date
end_date	query	string	false	End date
status	query	string	false	Status
limit	query	string	false	limit

Example responses

200 Response

[
  {
    "approver_ids": [],
    "badge_id": "8283876937",
    "change_log": [],
    "clock_at": "2024-07-15T13:26:47.389836Z",
    "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
    "clock_type": "clock",
    "clock_tz": "Etc/UTC",
    "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
    "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
    "direction": "IN",
    "id": "f4fded44-2717-485c-84b3-70982c696977",
    "server_clock_at": "2024-07-15T13:26:47.389838Z",
    "status": "recorded",
    "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
    "team_ids": [],
    "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Stampings

Renders a list of contract devices for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/contracts/devices/by_company/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/contracts/devices/by_company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/contracts/devices/by_company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/contracts/devices/by_company/{company_id}',
{
  method: 'GET',

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

<?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/stampings/contracts/devices/by_company/{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/stampings/contracts/devices/by_company/{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/stampings/contracts/devices/by_company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/contracts/devices/by_company/{company_id}

Renders a list of contract devices for a given company id...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id

Example responses

200 Response

[
  {
    "company_id": "4b5956fc-566e-478c-851f-c70616ddb669",
    "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
    "description": "Hotel & Lodging REITs",
    "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
    "device_info": {},
    "enabled": false,
    "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
    "name": "Fixed Line Telecommunications",
    "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractDevices

Updates chosen contract device

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/contracts/devices/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/contracts/devices/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/stampings/contracts/devices/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "4b5956fc-566e-478c-851f-c70616ddb669",
  "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
  "description": "Hotel & Lodging REITs",
  "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
  "device_info": {},
  "enabled": false,
  "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
  "name": "Fixed Line Telecommunications",
  "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/contracts/devices/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/stampings/contracts/devices/{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/stampings/contracts/devices/{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/stampings/contracts/devices/{id}", data)
    req.Header = headers

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

PUT /api/v1/stampings/contracts/devices/{id}

Updates chosen contract device...

Body parameter

{
  "company_id": "4b5956fc-566e-478c-851f-c70616ddb669",
  "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
  "description": "Hotel & Lodging REITs",
  "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
  "device_info": {},
  "enabled": false,
  "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
  "name": "Fixed Line Telecommunications",
  "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	contract device id
body	body	ContractDevice	false	contract device attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of contract devices for a given contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/contracts/{contract_id}/devices \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/contracts/{contract_id}/devices HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/contracts/{contract_id}/devices', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/contracts/{contract_id}/devices',
{
  method: 'GET',

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

<?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/stampings/contracts/{contract_id}/devices', 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/stampings/contracts/{contract_id}/devices");
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/stampings/contracts/{contract_id}/devices", data)
    req.Header = headers

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

GET /api/v1/stampings/contracts/{contract_id}/devices

Renders a list of contract devices for a given contract id...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id

Example responses

200 Response

[
  {
    "company_id": "4b5956fc-566e-478c-851f-c70616ddb669",
    "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
    "description": "Hotel & Lodging REITs",
    "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
    "device_info": {},
    "enabled": false,
    "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
    "name": "Fixed Line Telecommunications",
    "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractDevices

Updates chosen stamping contract areas

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/contracts/{id}/areas \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/contracts/{id}/areas HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/stampings/contracts/{id}/areas', headers = headers)

print(r.json())

const inputBody = '{
  "areas": [
    {}
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/contracts/{id}/areas',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/stampings/contracts/{id}/areas', 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/stampings/contracts/{id}/areas");
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/stampings/contracts/{id}/areas", data)
    req.Header = headers

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

PUT /api/v1/stampings/contracts/{id}/areas

Updates chosen stamping contract areas...

Body parameter

{
  "areas": [
    {}
  ]
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	contract id
body	body	ContractStampingAreas	false	contract areas attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Create stamping device

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/stampings/devices \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/stampings/devices HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/stampings/devices', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826",
  "description": "Tires",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "device_type": "nfc",
  "enabled": false,
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "name": "Leisure Goods",
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/devices',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/stampings/devices', 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/stampings/devices");
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/stampings/devices", data)
    req.Header = headers

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

POST /api/v1/stampings/devices

Create stamping device...

Body parameter

{
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826",
  "description": "Tires",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "device_type": "nfc",
  "enabled": false,
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "name": "Leisure Goods",
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e"
}

Parameters

Name	In	Type	Required	Description
body	body	StampingDevice	false	stamping device attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a list of stamping devices for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/devices/by_company/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/devices/by_company/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/devices/by_company/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/devices/by_company/{company_id}',
{
  method: 'GET',

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

<?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/stampings/devices/by_company/{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/stampings/devices/by_company/{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/stampings/devices/by_company/{company_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/devices/by_company/{company_id}

Renders a list of stamping devices for a given company id...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id

Example responses

200 Response

[
  {
    "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826",
    "description": "Tires",
    "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
    "device_type": "nfc",
    "enabled": false,
    "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
    "name": "Leisure Goods",
    "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	StampingDevices

Renders a list of stamping device by device id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/devices/by_device_id/{device_id}',
{
  method: 'GET',

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

<?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/stampings/devices/by_device_id/{device_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/stampings/devices/by_device_id/{device_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/stampings/devices/by_device_id/{device_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/devices/by_device_id/{device_id}

Renders a list of stamping device by device id...

Parameters

Name	In	Type	Required	Description
device_id	path	string	true	device id

Example responses

200 Response

[
  {
    "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826",
    "description": "Tires",
    "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
    "device_type": "nfc",
    "enabled": false,
    "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
    "name": "Leisure Goods",
    "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	StampingDevices

Updates chosen stamping device

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/devices/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/devices/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/stampings/devices/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826",
  "description": "Tires",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "device_type": "nfc",
  "enabled": false,
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "name": "Leisure Goods",
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/devices/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/stampings/devices/{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/stampings/devices/{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/stampings/devices/{id}", data)
    req.Header = headers

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

PUT /api/v1/stampings/devices/{id}

Updates chosen stamping device...

Body parameter

{
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826",
  "description": "Tires",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "device_type": "nfc",
  "enabled": false,
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "name": "Leisure Goods",
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e"
}

Parameters

Name	In	Type	Required	Description
id	path	string	true	stamping device id
body	body	StampingDevice	false	stamping device attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders a denormalized list of timestams

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/list/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/list/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/list/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/list/{company_id}',
{
  method: 'GET',

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

<?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/stampings/list/{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/stampings/list/{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/stampings/list/{company_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/list/{company_id}

Renders a list of timestamps for a given company id with details about user and workplace

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
contract_id	query	string	false	Contract UUID
clock_id	query	string	false	Clocking Device UUID
subsidiary_id	query	string	false	Workplace UUID
statuses	query	array[string]	false	Statuses
clock_type	query	string	false	Statuses
from_date	query	string	false	From Date
to_date	query	string	false	To Date

Example responses

200 Response

[
  {
    "badge_id": "8283876937",
    "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
    "clock_name": "Some Clocking Device",
    "clock_type": "clock",
    "clock_tz": "Etc/UTC",
    "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
    "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
    "direction": "IN",
    "id": "af2cfb51-7d4e-4213-b345-a9d47756ec34",
    "inserted_at": "2024-07-15T13:26:47.390963Z",
    "register_id": "AAA1234-2",
    "server_clock_at": "2024-07-15T13:26:47.390959Z",
    "status": "recorded",
    "subsdiriary_name": "Some Workplace",
    "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
    "updated_at": "2024-07-15T13:26:47.390965Z",
    "user_email": "foo@bar.com",
    "user_firstname": "Foo",
    "user_lastname": "Bar"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	DenormalizedStampings

Renders a list of stampings to be approved by a given contract id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/to_be_approved/{approver_id}',
{
  method: 'GET',

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

<?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/stampings/to_be_approved/{approver_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/stampings/to_be_approved/{approver_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/stampings/to_be_approved/{approver_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/to_be_approved/{approver_id}

Renders a list of stampings to be approved by a given contract id...

Parameters

Name	In	Type	Required	Description
approver_id	path	string	true	approver id
limit	query	string	false	limit

Example responses

200 Response

[
  {
    "approver_ids": [],
    "badge_id": "8283876937",
    "change_log": [],
    "clock_at": "2024-07-15T13:26:47.389836Z",
    "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
    "clock_type": "clock",
    "clock_tz": "Etc/UTC",
    "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
    "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
    "direction": "IN",
    "id": "f4fded44-2717-485c-84b3-70982c696977",
    "server_clock_at": "2024-07-15T13:26:47.389838Z",
    "status": "recorded",
    "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
    "team_ids": [],
    "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Stampings

Renders a list of stampings for a given company id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/{company_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/{company_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}',
{
  method: 'GET',

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

<?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/stampings/{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/stampings/{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/stampings/{company_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/{company_id}

Renders a list of stampings for a given company id...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id

Example responses

200 Response

[
  {
    "approver_ids": [],
    "badge_id": "8283876937",
    "change_log": [],
    "clock_at": "2024-07-15T13:26:47.389836Z",
    "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
    "clock_type": "clock",
    "clock_tz": "Etc/UTC",
    "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
    "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
    "direction": "IN",
    "id": "f4fded44-2717-485c-84b3-70982c696977",
    "server_clock_at": "2024-07-15T13:26:47.389838Z",
    "status": "recorded",
    "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
    "team_ids": [],
    "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	Stampings

Renders a company stamping area

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/{company_id}/areas/by_id/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/{company_id}/areas/by_id/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/areas/by_id/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/areas/by_id/{id}',
{
  method: 'GET',

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

<?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/stampings/{company_id}/areas/by_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/stampings/{company_id}/areas/by_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/stampings/{company_id}/areas/by_id/{id}", data)
    req.Header = headers

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

GET /api/v1/stampings/{company_id}/areas/by_id/{id}

Renders a company stamping area...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	area id

Example responses

200 Response

{
  "additional_details": {},
  "company_id": "40f3b529-6231-4e22-9cdb-2795bf67b1dc",
  "contracts": [],
  "description": "Health Care Providers",
  "detached": false,
  "enabled": false,
  "id": "a9c97cf7-4eca-49db-bb5a-21d7e8e78f9d",
  "lat": "17.57140909572334",
  "long": "69.22462284381567",
  "name": "Life Insurance",
  "radius": "50",
  "subsidiary_id": "534677de-fce4-4803-8e5b-487e370caad1"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	StampingArea

Deletes a stamping area for a company

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/areas/{id}',
{
  method: 'DELETE',

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

<?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/stampings/{company_id}/areas/{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/stampings/{company_id}/areas/{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/stampings/{company_id}/areas/{id}", data)
    req.Header = headers

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

DELETE /api/v1/stampings/{company_id}/areas/{id}

Deletes a stamping area for a company

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	area id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders contract last record

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/{company_id}/contract_last_record \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/{company_id}/contract_last_record HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/contract_last_record', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/contract_last_record',
{
  method: 'GET',

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

<?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/stampings/{company_id}/contract_last_record', 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/stampings/{company_id}/contract_last_record");
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/stampings/{company_id}/contract_last_record", data)
    req.Header = headers

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

GET /api/v1/stampings/{company_id}/contract_last_record

Renders contract last record...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
contract_id	query	string	false	Contract id
day	query	string	false	Day

Example responses

200 Response

{
  "approver_ids": [],
  "badge_id": "8283876937",
  "change_log": [],
  "clock_at": "2024-07-15T13:26:47.389836Z",
  "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "clock_type": "clock",
  "clock_tz": "Etc/UTC",
  "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
  "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
  "direction": "IN",
  "id": "f4fded44-2717-485c-84b3-70982c696977",
  "server_clock_at": "2024-07-15T13:26:47.389838Z",
  "status": "recorded",
  "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
  "team_ids": [],
  "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Stamping

Renders a company contract device

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/by_id/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/by_id/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/by_id/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/by_id/{id}',
{
  method: 'GET',

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

<?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/stampings/{company_id}/contracts/devices/by_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/stampings/{company_id}/contracts/devices/by_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/stampings/{company_id}/contracts/devices/by_id/{id}", data)
    req.Header = headers

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

GET /api/v1/stampings/{company_id}/contracts/devices/by_id/{id}

Renders a company contract device...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	contract device id

Example responses

200 Response

{
  "company_id": "4b5956fc-566e-478c-851f-c70616ddb669",
  "contract_id": "27ad53db-8200-43e1-886c-d4f44ec86b5e",
  "description": "Hotel & Lodging REITs",
  "device_id": "0b4c3c7e-69c0-4ddf-a889-9c7a9f062577",
  "device_info": {},
  "enabled": false,
  "id": "2b147d45-4e2a-44d4-88bf-f799bf9c37e5",
  "name": "Fixed Line Telecommunications",
  "subsidiary_id": "c5abdb1e-cc9d-4ac8-9a57-c86d5814e438"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ContractDevice

Deletes a contract device for a company

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/contracts/devices/{id}',
{
  method: 'DELETE',

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

<?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/stampings/{company_id}/contracts/devices/{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/stampings/{company_id}/contracts/devices/{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/stampings/{company_id}/contracts/devices/{id}", data)
    req.Header = headers

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

DELETE /api/v1/stampings/{company_id}/contracts/devices/{id}

Deletes a contract device for a company

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	contract device id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Daily Clock Records

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/{company_id}/daily_clock_records \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/{company_id}/daily_clock_records HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/daily_clock_records', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/daily_clock_records',
{
  method: 'GET',

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

<?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/stampings/{company_id}/daily_clock_records', 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/stampings/{company_id}/daily_clock_records");
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/stampings/{company_id}/daily_clock_records", data)
    req.Header = headers

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

GET /api/v1/stampings/{company_id}/daily_clock_records

Renders a list of clock records grouped by contract and day

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
contract_id	query	string	false	Contract Id
start_date	query	string	false	Start date
end_date	query	string	false	End date
team_id	query	string	false	Team Id
subsidiary_id	query	string	false	Subsidiary Id

Example responses

200 Response

[
  {
    "contract_id": "4ab77c4e-f4a4-48a8-a4c7-a090e73ddfaf",
    "days": [
      {
        "clock_records": [
          {
            "approver_ids": [
              "043276a1-769b-487f-98f3-e08957922c6b"
            ],
            "badge_id": "9436905599",
            "change_log": [],
            "clock_at": "2021-12-29 15:47:10",
            "clock_id": "0364ce66-e8e4-41b4-98bc-25331a08bab2",
            "clock_type": "clock",
            "clock_tz": "Europe/Rome",
            "company_id": "1176fb00-275c-4010-b9e5-7ea4b86485bb",
            "contract_id": "4ab77c4e-f4a4-48a8-a4c7-a090e73ddfaf",
            "day": "2021-12-23",
            "direction": "IN",
            "id": "a0a7985f-f319-4d3e-bc61-b737f3a715cf",
            "inserted_at": "2021-12-29 15:47:10Z",
            "overnight": false,
            "server_clock_at": "2021-12-23 10:00:00Z",
            "stamping_device_type": "bt",
            "status": "recorded",
            "subsidiary_id": "3aaf47f5-5b0b-4ec7-b3d8-b14bc62e604b",
            "team_ids": [],
            "updated_at": "2021-12-29 15:47:10Z",
            "user_id": "9c91928a-a6b7-40d2-b121-5de73ff8d8df"
          },
          {
            "approver_ids": [
              "b6aeb0cd-7a2f-443f-a2ad-af46b0acd111"
            ],
            "badge_id": "3391756748",
            "change_log": [],
            "clock_at": "2021-12-29 15:47:10",
            "clock_id": "e8c56a0a-a79b-4ae7-a725-c545307e3d25",
            "clock_type": "clock",
            "clock_tz": "Europe/Rome",
            "company_id": "1176fb00-275c-4010-b9e5-7ea4b86485bb",
            "contract_id": "4ab77c4e-f4a4-48a8-a4c7-a090e73ddfaf",
            "day": "2021-12-23",
            "direction": "OUT",
            "id": "ced6aa55-e39e-46cd-841d-71f73551f849",
            "inserted_at": "2021-12-29 15:47:10Z",
            "overnight": false,
            "server_clock_at": "2021-12-23 15:00:00Z",
            "stamping_device_type": "bt",
            "status": "recorded",
            "subsidiary_id": "581c9208-a403-4f37-b223-01213830dea4",
            "team_ids": [],
            "updated_at": "2021-12-29 15:47:10Z",
            "user_id": "9c91928a-a6b7-40d2-b121-5de73ff8d8df"
          }
        ],
        "day": "2021-12-22",
        "duration": 540
      }
    ],
    "total_duration": 780,
    "user_id": "9c91928a-a6b7-40d2-b121-5de73ff8d8df"
  }
]

Responses

Status	Meaning	Description	Schema
200	OK	Success	DailyClockRecords

Renders a company stamping device by device id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_device_id/{device_id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_device_id/{device_id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_device_id/{device_id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_device_id/{device_id}',
{
  method: 'GET',

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

<?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/stampings/{company_id}/devices/by_device_id/{device_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/stampings/{company_id}/devices/by_device_id/{device_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/stampings/{company_id}/devices/by_device_id/{device_id}", data)
    req.Header = headers

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

GET /api/v1/stampings/{company_id}/devices/by_device_id/{device_id}

Renders a company stamping device by device id...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
device_id	path	string	true	device id

Example responses

200 Response

{
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826",
  "description": "Tires",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "device_type": "nfc",
  "enabled": false,
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "name": "Leisure Goods",
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	StampingDevice

Renders a company stamping device by eid

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_eid/{eid} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_eid/{eid} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_eid/{eid}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_eid/{eid}',
{
  method: 'GET',

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

<?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/stampings/{company_id}/devices/by_eid/{eid}', 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/stampings/{company_id}/devices/by_eid/{eid}");
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/stampings/{company_id}/devices/by_eid/{eid}", data)
    req.Header = headers

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

GET /api/v1/stampings/{company_id}/devices/by_eid/{eid}

Renders a company stamping device by eid...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
eid	path	string	true	eid

Example responses

200 Response

{
  "beacon": {
    "beacon_id": "string",
    "description": "string",
    "name": "string"
  },
  "stamping_device": {
    "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826",
    "description": "Tires",
    "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
    "device_type": "nfc",
    "enabled": false,
    "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
    "name": "Leisure Goods",
    "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e"
  }
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	BeaconDevice

Renders a company stamping device

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/devices/by_id/{id}',
{
  method: 'GET',

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

<?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/stampings/{company_id}/devices/by_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/stampings/{company_id}/devices/by_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/stampings/{company_id}/devices/by_id/{id}", data)
    req.Header = headers

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

GET /api/v1/stampings/{company_id}/devices/by_id/{id}

Renders a company stamping device...

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	device id

Example responses

200 Response

{
  "company_id": "ebb645d7-c562-43ec-97a2-c052ce90f826",
  "description": "Tires",
  "device_id": "3e18bf32-d453-4262-aa3a-8c38ba94a6bd",
  "device_type": "nfc",
  "enabled": false,
  "id": "e21c0a21-4538-4b07-9672-6a1a57426679",
  "name": "Leisure Goods",
  "subsidiary_id": "99faee9b-cdf7-4e92-b844-778df4a1581e"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	StampingDevice

Deletes a stamping device for a company

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/stampings/{company_id}/devices/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/stampings/{company_id}/devices/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/stampings/{company_id}/devices/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{company_id}/devices/{id}',
{
  method: 'DELETE',

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

<?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/stampings/{company_id}/devices/{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/stampings/{company_id}/devices/{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/stampings/{company_id}/devices/{id}", data)
    req.Header = headers

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

DELETE /api/v1/stampings/{company_id}/devices/{id}

Deletes a stamping device for a company

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id
id	path	string	true	device id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Approves stamping for a contract

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}?closer_id=string \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}?closer_id=string HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}', params={
  'closer_id': 'string'
}, headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/approve/{id}?closer_id=string',
{
  method: 'PUT',

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

<?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/stampings/{contract_id}/approve/{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/stampings/{contract_id}/approve/{id}?closer_id=string");
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/stampings/{contract_id}/approve/{id}", data)
    req.Header = headers

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

PUT /api/v1/stampings/{contract_id}/approve/{id}

Approves stamping for a contract...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
id	path	string	true	stamping id
closer_id	query	string	true	approver id
approver_notes	query	string	false	approver notes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Records a user stamping clock

Code samples

# You can also use wget
curl -X POST https://api.fluida.io/api/v1/stampings/{contract_id}/clock \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

POST https://api.fluida.io/api/v1/stampings/{contract_id}/clock HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.post('https://api.fluida.io/api/v1/stampings/{contract_id}/clock', headers = headers)

print(r.json())

const inputBody = '{
  "approver_ids": [],
  "badge_id": "8283876937",
  "clock_at": "2024-07-15T13:26:47.389773Z",
  "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "clock_type": "clock",
  "clock_tz": "Etc/UTC",
  "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
  "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
  "server_clock_at": "2024-07-15T13:26:47.389775Z",
  "sign": "signature",
  "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
  "team_ids": [],
  "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/clock',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/stampings/{contract_id}/clock', 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/stampings/{contract_id}/clock");
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/stampings/{contract_id}/clock", data)
    req.Header = headers

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

POST /api/v1/stampings/{contract_id}/clock

Records a user stamping clock...

Body parameter

{
  "approver_ids": [],
  "badge_id": "8283876937",
  "clock_at": "2024-07-15T13:26:47.389773Z",
  "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "clock_type": "clock",
  "clock_tz": "Etc/UTC",
  "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
  "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
  "server_clock_at": "2024-07-15T13:26:47.389775Z",
  "sign": "signature",
  "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
  "team_ids": [],
  "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de"
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
body	body	StampingRequest	false	stamping attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
200	OK	Ok	None
401	Unauthorized	Unauthorized	Unauthorized

Deletes a stamping for a contract

Code samples

# You can also use wget
curl -X DELETE https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id} \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

DELETE https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id} HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.delete('https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id}',
{
  method: 'DELETE',

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

<?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/stampings/{contract_id}/clock/{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/stampings/{contract_id}/clock/{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/stampings/{contract_id}/clock/{id}", data)
    req.Header = headers

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

DELETE /api/v1/stampings/{contract_id}/clock/{id}

Deletes a stamping for a contract

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
id	path	string	true	clock id

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Updates a stamping for a contract

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "clock_at": "string",
  "clock_tz": "string",
  "direction": "string",
  "notes": "string",
  "subsidiary_id": "string",
  "updated_by": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/clock/{id}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/stampings/{contract_id}/clock/{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/stampings/{contract_id}/clock/{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/stampings/{contract_id}/clock/{id}", data)
    req.Header = headers

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

PUT /api/v1/stampings/{contract_id}/clock/{id}

Updates a stamping for a contract

Body parameter

{
  "clock_at": "string",
  "clock_tz": "string",
  "direction": "string",
  "notes": "string",
  "subsidiary_id": "string",
  "updated_by": "string"
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
id	path	string	true	clock id
body	body	StampingUpdate	false	stamping attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Renders clock record by id

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id} \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id} HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id}', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/get/{id}',
{
  method: 'GET',

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

<?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/stampings/{contract_id}/get/{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/stampings/{contract_id}/get/{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/stampings/{contract_id}/get/{id}", data)
    req.Header = headers

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

GET /api/v1/stampings/{contract_id}/get/{id}

Renders clock record by id.

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
id	path	string	true	stamping id

Example responses

200 Response

{
  "approver_ids": [],
  "badge_id": "8283876937",
  "change_log": [],
  "clock_at": "2024-07-15T13:26:47.389836Z",
  "clock_id": "6450de7c-9c50-4bf1-b9c0-9aceb2accb30",
  "clock_type": "clock",
  "clock_tz": "Etc/UTC",
  "company_id": "68524333-4a0b-4fb5-b738-9f2da914cf85",
  "contract_id": "bf718392-3f0f-4924-b8d0-01ef86679b0c",
  "direction": "IN",
  "id": "f4fded44-2717-485c-84b3-70982c696977",
  "server_clock_at": "2024-07-15T13:26:47.389838Z",
  "status": "recorded",
  "subsidiary_id": "cc966c33-e6de-4c6a-a108-841b01c8d051",
  "team_ids": [],
  "user_id": "6b77239c-76cf-4ed4-8328-92cf898434de"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	Stamping

Rejects stamping for a contract

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}?closer_id=string \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}?closer_id=string HTTP/1.1
Host: api.fluida.io
Accept: */*

import requests
headers = {
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}', params={
  'closer_id': 'string'
}, headers = headers)

print(r.json())

const headers = {
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/reject/{id}?closer_id=string',
{
  method: 'PUT',

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

<?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/stampings/{contract_id}/reject/{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/stampings/{contract_id}/reject/{id}?closer_id=string");
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/stampings/{contract_id}/reject/{id}", data)
    req.Header = headers

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

PUT /api/v1/stampings/{contract_id}/reject/{id}

Rejects stamping for a contract...

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id
id	path	string	true	stamping id
closer_id	query	string	true	rejector id
rejector_notes	query	string	false	rejector notes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Adds notes to chosen stamping

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/stampings/{contract_id}/stamping/{id}/add_notes \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/stampings/{contract_id}/stamping/{id}/add_notes HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/stampings/{contract_id}/stamping/{id}/add_notes', headers = headers)

print(r.json())

const inputBody = '{
  "notes": "string",
  "updated_by": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/stampings/{contract_id}/stamping/{id}/add_notes',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

<?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/stampings/{contract_id}/stamping/{id}/add_notes', 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/stampings/{contract_id}/stamping/{id}/add_notes");
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/stampings/{contract_id}/stamping/{id}/add_notes", data)
    req.Header = headers

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

PUT /api/v1/stampings/{contract_id}/stamping/{id}/add_notes

Adds notes to chosen stamping

Body parameter

{
  "notes": "string",
  "updated_by": "string"
}

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	stamping id
id	path	string	true	stamping id
body	body	StampingNotes	false	stamping attributes

Example responses

401 Response

Responses

Status	Meaning	Description	Schema
202	Accepted	Accepted	None
401	Unauthorized	Unauthorized	Unauthorized

Status

API Status

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/status \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer {access-token}'

GET https://api.fluida.io/api/v1/status HTTP/1.1
Host: api.fluida.io
Accept: application/json

import requests
headers = {
  'Accept': 'application/json',
  'Authorization': 'Bearer {access-token}'
}

r = requests.get('https://api.fluida.io/api/v1/status', headers = headers)

print(r.json())

const headers = {
  'Accept':'application/json',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/status',
{
  method: 'GET',

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

<?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/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/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{"application/json"},
        "Authorization": []string{"Bearer {access-token}"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/status", data)
    req.Header = headers

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

GET /api/v1/status

Return API overall status

Example responses

200 Response

{
  "status": "OK",
  "timestamp": "2019-10-24T14:10:42.480641Z"
}

Responses

Status	Meaning	Description	Schema
200	OK	Success	ApiStatus

Subscription

Check if coupon is valid

Code samples

# You can also use wget
curl -X GET https://api.fluida.io/api/v1/coupon_check/{coupon}

GET https://api.fluida.io/api/v1/coupon_check/{coupon} HTTP/1.1
Host: api.fluida.io

import requests

r = requests.get('https://api.fluida.io/api/v1/coupon_check/{coupon}')

print(r.json())

fetch('https://api.fluida.io/api/v1/coupon_check/{coupon}',
{
  method: 'GET'

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

<?php

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/coupon_check/{coupon}', 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/coupon_check/{coupon}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/coupon_check/{coupon}", data)
    req.Header = headers

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

GET /api/v1/coupon_check/{coupon}

Check if coupon is valid...

Parameters

Name	In	Type	Required	Description
coupon	path	string	true	coupon

Responses

Status	Meaning	Description	Schema
200	OK	Success	None

update subscription plan

Code samples

# You can also use wget
curl -X PUT https://api.fluida.io/api/v1/subscription/plans/{id} \
  -H 'Content-Type: application/json' \
  -H 'Accept: */*' \
  -H 'Authorization: Bearer {access-token}'

PUT https://api.fluida.io/api/v1/subscription/plans/{id} HTTP/1.1
Host: api.fluida.io
Content-Type: application/json
Accept: */*

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': '*/*',
  'Authorization': 'Bearer {access-token}'
}

r = requests.put('https://api.fluida.io/api/v1/subscription/plans/{id}', headers = headers)

print(r.json())

const inputBody = '{
  "plan": {
    "features": [
      "export"
    ],
    "name": "Starter",
    "period_unit": "month",
    "plan_family": "starter",
    "price": 2,
    "sku": "starter"
  }
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'*/*',
  'Authorization':'Bearer {access-token}'
};

fetch('https://api.fluida.io/api/v1/subscription/plans/{id}',
{