Fluida API v1.0.0

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Fluida API integration guide

Base URLs:

• https://api.fluida.io

Terms of service

Authentication

• API Key (ApiKey)

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

• oAuth2 authentication.

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

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

Activity

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

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/activities/activity', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /api/v1/activities/activity

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

Body parameter

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

Parameters

Name	In	Type	Required	Description
body	body	Activity	false	Activity attributes

Example responses

401 Response

Responses

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

Query for activities

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/activities/activity/company/{company_id}/aggregate/{first_level}/{second_level}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/company/{company_id}/aggregate/{first_level}/{second_level}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Query for activities

Body parameter

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

Parameters

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

Example responses

401 Response

Responses

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

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

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/activity/report_minutes_not_completed/readable/company/{company_id}/from/{from}/to/{to}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/report_minutes_not_completed/readable/company/{company_id}/from/{from}/to/{to}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

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

Parameters

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

Example responses

200 Response

Responses

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

Returns activities of a specific company

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/activity/reported/{company_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/reported/{company_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Returns activities of a specific company

Parameters

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

Example responses

200 Response

Responses

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

List contract activities

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/activity/reported/{company_id}/{contract_id}/{date}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/reported/{company_id}/{contract_id}/{date}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Returns activities of a specific contract for a specific date

Parameters

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

Example responses

200 Response

Responses

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

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

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/per/{contract_id}/from/{from}/to/{to}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/per/{contract_id}/from/{from}/to/{to}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

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

Parameters

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

Example responses

200 Response

Responses

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

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

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/readable/company/{company_id}/from/{from}/to/{to}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/schedules_not_completed/readable/company/{company_id}/from/{from}/to/{to}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

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

Parameters

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

Example responses

200 Response

Responses

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

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

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/activity/suggested/{contract_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/suggested/{contract_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

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

Parameters

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

Example responses

200 Response

Responses

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

Deletes an activity

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/activities/activity/{activity_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/{activity_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Deletes an activity

Parameters

Name	In	Type	Required	Description
activity_id	path	string	true	Activity ID

Example responses

401 Response

Responses

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

Get Activity by ID

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/activity/{activity_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/{activity_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Get Activity by ID

Parameters

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

Example responses

200 Response

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

Responses

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

Updates an activity

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/activities/activity/{activity_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/{activity_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates an activity

Body parameter

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

Parameters

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

Example responses

401 Response

Responses

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

Updates an activity with new attachments

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates an activity with new attachments

Body parameter

document: string

Parameters

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

Example responses

401 Response

Responses

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

Updates an activity removing an attachment

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates an activity removing an attachment

Parameters

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

Example responses

401 Response

Responses

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

Download an activity attachment

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/{activity_id}/attachment/{attachment_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Download an activity attachment

Parameters

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

Example responses

401 Response

Responses

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

Updates an activity removing the picture

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates an activity removing picture

Parameters

Name	In	Type	Required	Description
activity_id	path	string	true	Activity ID

Example responses

401 Response

Responses

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

Updates an activity with new picture

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/x-www-form-urlencoded',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates an activity with new picture

Body parameter

document: string

Parameters

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

Example responses

401 Response

Responses

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

Download an activity picture

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture/{picture_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity/{activity_id}/picture/{picture_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Download an activity picture

Parameters

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

Example responses

401 Response

Responses

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

Creates an activity type

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/activities/activity_types', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity_types");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /api/v1/activities/activity_types

Creates an activity type

Body parameter

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

Parameters

Name	In	Type	Required	Description
body	body	ActivityType	false	ActivityType attributes

Example responses

201 Response

Responses

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

Renders a list of Activity Types with a specific Company ID

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/activity_types/by_company/{company_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity_types/by_company/{company_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Renders a list of Activity Types with a specific Company ID

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	Company ID

Example responses

200 Response

Responses

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

Deletes an activity type

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Deletes an activity type

Parameters

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

Example responses

200 Response

Responses

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

Get Activity Type by ID

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Get Activity Type by ID

Parameters

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

Example responses

200 Response

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

Responses

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

Updates an activity type

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/activity_types/{activity_type_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates an activity type

Body parameter

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

Parameters

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

Example responses

200 Response

Responses

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

Creates a customer

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/activities/customers', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/customers");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /api/v1/activities/customers

Creates a customer

Body parameter

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

Parameters

Name	In	Type	Required	Description
body	body	Customer	false	Customer attributes

Example responses

201 Response

Responses

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

Renders a list of Customers with a specific Company ID

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/customers/by_company/{company_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/customers/by_company/{company_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Renders a list of Customers with a specific Company ID

Parameters

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

Example responses

200 Response

Responses

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

Deletes a Customer

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/activities/customers/{customer_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/customers/{customer_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Deletes a Customer

Parameters

Name	In	Type	Required	Description
customer_id	path	string	true	Customer ID

Example responses

200 Response

Responses

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

Get Customer by ID

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/customers/{customer_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/customers/{customer_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Get Customer by ID

Parameters

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

Example responses

200 Response

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

Responses

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

Updates a Customer

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/activities/customers/{customer_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/customers/{customer_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates a Customer

Body parameter

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

Parameters

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

Example responses

200 Response

Responses

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

Return the notes of a daily schedule

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes", data)
    req.Header = headers

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

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

Return the notes of a daily schedule

Parameters

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

Example responses

200 Response

{
  "notes": "string"
}

Responses

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

Updates a daily schedule with new notes

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("PUT", "https://api.fluida.io/api/v1/activities/daily_schedule/date/{date}/contract/{contract_id}/notes", data)
    req.Header = headers

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

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

Updates a daily schedule with new notes

Body parameter

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

Parameters

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

Example responses

401 Response

Responses

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

Creates an Order

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/activities/orders', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/orders");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /api/v1/activities/orders

Creates an Order

Body parameter

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

Parameters

Name	In	Type	Required	Description
body	body	Order	false	Order attributes

Example responses

201 Response

Responses

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

Renders a list of Orders with a specific Company ID

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/orders/by_company/{company_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/orders/by_company/{company_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Renders a list of Orders with a specific Company ID

Parameters

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

Example responses

200 Response

Responses

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

Deletes an Order

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/activities/orders/{order_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/orders/{order_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Deletes an Order

Parameters

Name	In	Type	Required	Description
order_id	path	string	true	Order ID

Example responses

200 Response

Responses

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

Get Order by ID

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/activities/orders/{order_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/orders/{order_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Get Order by ID

Parameters

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

Example responses

200 Response

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

Responses

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

Updates an Order

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/activities/orders/{order_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/activities/orders/{order_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates an Order

Body parameter

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

Parameters

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

Example responses

200 Response

Responses

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

Approval

Get default approval chain

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/approval_chain', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/approval_chain");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Get default approval chain

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id

Example responses

200 Response

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

Responses

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

Update default approval chain

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/companies/{company_id}/approval_chain', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/approval_chain");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Update default approval chain

Body parameter

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

Parameters

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

Example responses

401 Response

{
  "errors": "string"
}

Responses

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

Get default approval chains configuration

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/companies/{company_id}/approval_chains_by_feature', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/companies/{company_id}/approval_chains_by_feature");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Get default approval chains configuration

Parameters

Name	In	Type	Required	Description
company_id	path	string	true	company id

Example responses

200 Response

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

Responses

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

Update contract approval chains configuration

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Update contract approval chains configuration

Body parameter

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

Parameters

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

Example responses

401 Response

Responses

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

Get contract approval chain

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Get contract approval chain

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id

Example responses

200 Response

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

Responses

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

Update contract approval chain

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chain");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Update contract approval chain

Body parameter

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

Parameters

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

Example responses

401 Response

Responses

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

Get contract approval chains configuration

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/contracts/{contract_id}/approval_chains_by_feature");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Get contract approval chains configuration

Parameters

Name	In	Type	Required	Description
contract_id	path	string	true	contract id

Example responses

200 Response

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

Responses

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

Get an approval chain template

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Get an approval chain template

Parameters

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

Example responses

200 Response

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

Responses

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

Create an approval chain template

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Create an approval chain template

Body parameter

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

Parameters

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

Example responses

201 Response

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

Responses

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

Delete an approval chain template

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Delete an approval chain template

Parameters

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

Example responses

200 Response

Responses

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

Update an approval chain template

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/requests/{company_id}/approval_chain_templates/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Update an approval chain template

Body parameter

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

Parameters

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

Example responses

200 Response

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

Responses

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

Calendar

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

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/calendar/company/{company_id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/calendar/company/{company_id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

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

Parameters

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

Example responses

200 Response

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

Responses

Status	Meaning	Description	Schema
200	OK	Success	ActualCalendarEntries

Summary of actual working days with the entry list

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/calendar/company/{company_id}/actual_calendar_with_summary', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/calendar/company/{company_id}/actual_calendar_with_summary");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

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

Parameters

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

Example responses

200 Response

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

Responses

Status	Meaning	Description	Schema
200	OK	Success	ActualCalendarSummary

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

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/calendar/company/{company_id}/light', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/calendar/company/{company_id}/light");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

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

Parameters

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

Example responses

200 Response

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

Responses

Status	Meaning	Description	Schema
200	OK	Success	LightActualCalendarEntries

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

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_contract', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_contract");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

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

Parameters

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

Example responses

200 Response

null

Responses

Status	Meaning	Description	Schema
200	OK	Success	Inline

Response Schema

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

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_day', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/calendar/company/{company_id}/summary_by_day");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

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

Parameters

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

Example responses

200 Response

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

Responses

Status	Meaning	Description	Schema
200	OK	Success	DayCalendarSummaries

Creates a company holiday

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://api.fluida.io/api/v1/calendar/company_holidays', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/calendar/company_holidays");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

POST /api/v1/calendar/company_holidays

Creates a company holiday...

Body parameter

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

Parameters

Name	In	Type	Required	Description
body	body	CompanyHoliday	false	holiday attributes

Example responses

401 Response

Responses

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

Deletes a company holiday

Code samples

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

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

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

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

print(r.json())

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

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('DELETE','https://api.fluida.io/api/v1/calendar/company_holidays/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/calendar/company_holidays/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Deletes a company holiday...

Parameters

Name	In	Type	Required	Description
id	path	string	true	company id

Example responses

401 Response

Responses

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

Updates a company holiday

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/calendar/company_holidays/{id}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.fluida.io/api/v1/calendar/company_holidays/{id}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

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

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

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

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

Updates a company holiday...

Body parameter

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

Parameters

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

Example responses

401 Response

Responses

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

Fix mismatches on calendar day

Code samples

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

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

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

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

print(r.json())

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

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

<?php

require 'vendor/autoload.php';

$headers = array(
    'Content-Type' => 'application/json',
    'Accept' => '*/*',
    'Authorization' => 'Bearer {access-token}',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('PUT','https://api.fluida.io/api/v1/calendar/contracts/{contract_id}/fix_mismatches', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }<