NAV Navbar
Shell HTTP Python JavaScript PHP Java Go

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:

Terms of service

Authentication

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());
 }<