Introduction

To try this api, pls use the endpoint Authentication < Get Api Token, after that you can use the "Try it out" button to simulate some request, insert all required fields and paste the access token in the Authorization header: Bearer

This documentation aims to provide all the information you need to work with the scan4myhealth API.

Base URL

http://scan.test

Authenticating requests

This API is not authenticated.

AAuthentication

APIs for Authentication

Example request:

curl --request POST \
    "http://scan.test/api/auth/login" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"ducimus\",
    \"password\": \"ducimus\",
    \"mac_address\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/auth/login"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "ducimus",
    "password": "ducimus",
    "mac_address": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/auth/login',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'ducimus',
            'password' => 'ducimus',
            'mac_address' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/auth/login'
payload = {
    "email": "ducimus",
    "password": "ducimus",
    "mac_address": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Example request:

curl --request POST \
    "http://scan.test/api/auth/login/web" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"ducimus\",
    \"password\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/auth/login/web"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "ducimus",
    "password": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/auth/login/web',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'ducimus',
            'password' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/auth/login/web'
payload = {
    "email": "ducimus",
    "password": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Example request:

curl --request POST \
    "http://scan.test/api/auth/login-api" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"ducimus\",
    \"password\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/auth/login-api"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "ducimus",
    "password": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/auth/login-api',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'ducimus',
            'password' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/auth/login-api'
payload = {
    "email": "ducimus",
    "password": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Example request:

curl --request POST \
    "http://scan.test/api/auth/signup" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"first_name\": \"ducimus\",
    \"last_name\": \"ducimus\",
    \"email\": \"megane.corwin@example.org\",
    \"username\": \"lps-dpw_o\",
    \"password\": \"ducimus\",
    \"password_confirmation\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/auth/signup"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "first_name": "ducimus",
    "last_name": "ducimus",
    "email": "megane.corwin@example.org",
    "username": "lps-dpw_o",
    "password": "ducimus",
    "password_confirmation": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/auth/signup',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'first_name' => 'ducimus',
            'last_name' => 'ducimus',
            'email' => 'megane.corwin@example.org',
            'username' => 'lps-dpw_o',
            'password' => 'ducimus',
            'password_confirmation' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/auth/signup'
payload = {
    "first_name": "ducimus",
    "last_name": "ducimus",
    "email": "megane.corwin@example.org",
    "username": "lps-dpw_o",
    "password": "ducimus",
    "password_confirmation": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/auth/signup

Body Parameters

first_name string

last_name string

email string

o email.

username string

Must contain only letters, numbers, dashes and underscores.

password string

password_confirmation string

Validate session

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/auth/verify_token" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/auth/verify_token"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/auth/verify_token',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/auth/verify_token'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Received response:

Request failed with error:

Logout

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/auth/logout" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/auth/logout"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/auth/logout',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/auth/logout'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Validate session

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/auth/validate" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/auth/validate"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/auth/validate',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/auth/validate'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Validate session

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/auth/validate-mobile" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/auth/validate-mobile"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/auth/validate-mobile',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/auth/validate-mobile'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Aggregates

APIs for managing aggregates

Provide aggregates (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/aggregates" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/aggregates"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/aggregates',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/aggregates'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store aggregates

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/aggregates" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"emergency_relative\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"closest_location\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\",
    \"notes\": \"ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn\",
    \"user_id\": 9
}"

const url = new URL(
    "http://scan.test/api/aggregates"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "emergency_relative": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "closest_location": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "notes": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "user_id": 9
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/aggregates',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'emergency_relative' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'closest_location' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
            'notes' => 'ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn',
            'user_id' => 9,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/aggregates'
payload = {
    "emergency_relative": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "closest_location": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "notes": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "user_id": 9
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide one aggregate

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/aggregates/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/aggregates/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/aggregates/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/aggregates/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update one aggregate

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/aggregates/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"emergency_relative\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"closest_location\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\",
    \"notes\": \"ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn\",
    \"user_id\": 9
}"

const url = new URL(
    "http://scan.test/api/aggregates/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "emergency_relative": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "closest_location": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "notes": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "user_id": 9
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/aggregates/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'emergency_relative' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'closest_location' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
            'notes' => 'ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn',
            'user_id' => 9,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/aggregates/9'
payload = {
    "emergency_relative": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "closest_location": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "notes": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "user_id": 9
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/aggregates/{id}

URL Parameters

id integer

The ID of the aggregate.

Body Parameters

emergency_relative string

max.string.

closest_location string

max.string.

notes string

max.string.

user_id integer

Delete one aggregate

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/aggregates/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/aggregates/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/aggregates/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/aggregates/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Appointment

APIs for managing appointments

Provide appointments (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/appointments" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointments"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/appointments',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointments'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide appointments

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/appointments/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointments/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/appointments/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointments/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store an appointment

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/appointments" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"subject\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"location\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\",
    \"observation\": \"ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn\",
    \"date_begin\": \"2023-03-16T16:18:12\",
    \"date_end\": \"2023-03-16T16:18:12\",
    \"user_id\": 9,
    \"appointmentCategory_id\": \"ducimus\",
    \"appointmentPriority_id\": \"ducimus\",
    \"responsible_id\": 9
}"

const url = new URL(
    "http://scan.test/api/appointments"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "location": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "observation": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "date_begin": "2023-03-16T16:18:12",
    "date_end": "2023-03-16T16:18:12",
    "user_id": 9,
    "appointmentCategory_id": "ducimus",
    "appointmentPriority_id": "ducimus",
    "responsible_id": 9
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/appointments',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'subject' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'location' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
            'observation' => 'ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn',
            'date_begin' => '2023-03-16T16:18:12',
            'date_end' => '2023-03-16T16:18:12',
            'user_id' => 9,
            'appointmentCategory_id' => 'ducimus',
            'appointmentPriority_id' => 'ducimus',
            'responsible_id' => 9,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointments'
payload = {
    "subject": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "location": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "observation": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "date_begin": "2023-03-16T16:18:12",
    "date_end": "2023-03-16T16:18:12",
    "user_id": 9,
    "appointmentCategory_id": "ducimus",
    "appointmentPriority_id": "ducimus",
    "responsible_id": 9
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/appointments

Body Parameters

subject string

max.string.

location string

max.string.

observation string

max.string.

date_begin string

encontro.

date_end string

encontro.

user_id integer

appointmentCategory_id string

appointmentPriority_id string

responsible_id integer

Provide one appointment

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/appointments/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointments/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/appointments/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointments/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update one appointment

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/appointments/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"subject\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"location\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\",
    \"observation\": \"ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn\",
    \"date_begin\": \"2023-03-16T16:18:12\",
    \"date_end\": \"2023-03-16T16:18:12\",
    \"user_id\": \"ducimus\",
    \"state\": \"Cancelled\",
    \"appointmentCategory_id\": \"ducimus\",
    \"appointmentPriority_id\": \"ducimus\",
    \"responsible_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/appointments/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "location": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "observation": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "date_begin": "2023-03-16T16:18:12",
    "date_end": "2023-03-16T16:18:12",
    "user_id": "ducimus",
    "state": "Cancelled",
    "appointmentCategory_id": "ducimus",
    "appointmentPriority_id": "ducimus",
    "responsible_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/appointments/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'subject' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'location' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
            'observation' => 'ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn',
            'date_begin' => '2023-03-16T16:18:12',
            'date_end' => '2023-03-16T16:18:12',
            'user_id' => 'ducimus',
            'state' => 'Cancelled',
            'appointmentCategory_id' => 'ducimus',
            'appointmentPriority_id' => 'ducimus',
            'responsible_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointments/9'
payload = {
    "subject": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "location": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "observation": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "date_begin": "2023-03-16T16:18:12",
    "date_end": "2023-03-16T16:18:12",
    "user_id": "ducimus",
    "state": "Cancelled",
    "appointmentCategory_id": "ducimus",
    "appointmentPriority_id": "ducimus",
    "responsible_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/appointments/{id}

URL Parameters

id integer

The ID of the appointment.

Body Parameters

subject string

max.string.

location string

max.string.

observation string

max.string.

date_begin string

encontro.

date_end string

encontro.

user_id string

state string

Must be one of Done, Waiting, Failed, or Cancelled.

appointmentCategory_id string

appointmentPriority_id string

responsible_id string

Delete one appointment

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/appointments/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointments/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/appointments/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointments/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Appointment Categories

APIs for managing appointment categories

Provide appointment categories (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/appointment-categories" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointment-categories"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/appointment-categories',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-categories'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide appointment categories (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/appointment-categories/all" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointment-categories/all"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/appointment-categories/all',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-categories/all'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store an appointment category

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/appointment-categories" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/appointment-categories"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/appointment-categories',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-categories'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide one appointment category

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/appointment-categories/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointment-categories/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/appointment-categories/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-categories/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update one appointment category

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/appointment-categories/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/appointment-categories/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/appointment-categories/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-categories/1'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete an appointment category

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/appointment-categories/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointment-categories/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/appointment-categories/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-categories/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Appointment Priorities

APIs for managing appointment priorities

Provide appointment priorities (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/appointment-priorities" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointment-priorities"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/appointment-priorities',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-priorities'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide appointment priorities (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/appointment-priorities/all" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointment-priorities/all"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/appointment-priorities/all',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-priorities/all'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store an appointment priority

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/appointment-priorities" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/appointment-priorities"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/appointment-priorities',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-priorities'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide one appointment priority

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/appointment-priorities/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointment-priorities/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/appointment-priorities/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-priorities/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Apdate one appointment priority

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/appointment-priorities/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/appointment-priorities/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/appointment-priorities/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-priorities/1'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete an appointment priority

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/appointment-priorities/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointment-priorities/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/appointment-priorities/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-priorities/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Appointment Task Types

APIs for managing appointment task types

Provide appointment task types (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/appointment-task-types" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointment-task-types"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/appointment-task-types',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-task-types'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store an appointment task type

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/appointment-task-types" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/appointment-task-types"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/appointment-task-types',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-task-types'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide one appointment task type

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/appointment-task-types/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointment-task-types/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/appointment-task-types/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-task-types/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update one appointment task type

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/appointment-task-types/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/appointment-task-types/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/appointment-task-types/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-task-types/1'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete an appointment task type

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/appointment-task-types/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/appointment-task-types/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/appointment-task-types/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/appointment-task-types/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Association between Users and Devices

APIs for associations between devices and users

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/user-devices" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/user-devices"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/user-devices',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/user-devices'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/user-devices" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ducimus\",
    \"user_id\": \"ducimus\",
    \"device_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/user-devices"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "ducimus",
    "user_id": "ducimus",
    "device_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/user-devices',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'ducimus',
            'user_id' => 'ducimus',
            'device_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/user-devices'
payload = {
    "name": "ducimus",
    "user_id": "ducimus",
    "device_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Display the specified resource.

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/user-devices/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/user-devices/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/user-devices/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/user-devices/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update the specified resource in storage.

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/user-devices/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ducimus\",
    \"user_id\": \"ducimus\",
    \"device_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/user-devices/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "ducimus",
    "user_id": "ducimus",
    "device_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/user-devices/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'ducimus',
            'user_id' => 'ducimus',
            'device_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/user-devices/9'
payload = {
    "name": "ducimus",
    "user_id": "ducimus",
    "device_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/user-devices/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/user-devices/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/user-devices/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/user-devices/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Attachment

APIs for managing attachment

Provide attachments (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/attachments" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/attachments"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/attachments',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachments'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store an attachment

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/attachments" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "description=lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp" \
    --form "privacy=ducimus" \
    --form "clinic_id=9" \
    --form "user_id=9" \
    --form "responsible_id=9" \
    --form "attachmentCategory_id=9" \
    --form "file=@/tmp/php5mmSqv"

const url = new URL(
    "http://scan.test/api/attachments"
);

const headers = {
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('description', 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp');
body.append('privacy', 'ducimus');
body.append('clinic_id', '9');
body.append('user_id', '9');
body.append('responsible_id', '9');
body.append('attachmentCategory_id', '9');
body.append('file', document.querySelector('input[name="file"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/attachments',
    [
        'headers' => [
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'description',
                'contents' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp'
            ],
            [
                'name' => 'privacy',
                'contents' => 'ducimus'
            ],
            [
                'name' => 'clinic_id',
                'contents' => '9'
            ],
            [
                'name' => 'user_id',
                'contents' => '9'
            ],
            [
                'name' => 'responsible_id',
                'contents' => '9'
            ],
            [
                'name' => 'attachmentCategory_id',
                'contents' => '9'
            ],
            [
                'name' => 'file',
                'contents' => fopen('/tmp/php5mmSqv', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachments'
files = {
  'file': open('/tmp/php5mmSqv', 'rb')
}
payload = {
    "description": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "privacy": "ducimus",
    "clinic_id": 9,
    "user_id": 9,
    "responsible_id": 9,
    "attachmentCategory_id": 9
}
headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, files=files, data=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/attachments

Body Parameters

file file

Must be a file. max.file.

description string

max.string.

privacy string

clinic_id integer optional

obrigatório_sem.

user_id integer optional

obrigatório_sem.

responsible_id integer

attachmentCategory_id integer

Store an attachment

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/attachments/download" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/attachments/download"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/attachments/download',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachments/download'
payload = {
    "id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide an attachment

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/attachments/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/attachments/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/attachments/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachments/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update an attachment

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/attachments/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"description\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"name\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\",
    \"privacy\": false,
    \"type\": \"kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny\",
    \"size\": \"rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy\",
    \"clinic_id\": 9,
    \"user_id\": 9,
    \"responsible_id\": 9,
    \"attachmentCategory_id\": 9
}"

const url = new URL(
    "http://scan.test/api/attachments/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "description": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "name": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "privacy": false,
    "type": "kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny",
    "size": "rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy",
    "clinic_id": 9,
    "user_id": 9,
    "responsible_id": 9,
    "attachmentCategory_id": 9
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/attachments/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'description' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'name' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
            'privacy' => false,
            'type' => 'kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny',
            'size' => 'rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy',
            'clinic_id' => 9,
            'user_id' => 9,
            'responsible_id' => 9,
            'attachmentCategory_id' => 9,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachments/9'
payload = {
    "description": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "name": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "privacy": false,
    "type": "kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny",
    "size": "rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy",
    "clinic_id": 9,
    "user_id": 9,
    "responsible_id": 9,
    "attachmentCategory_id": 9
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/attachments/{id}

URL Parameters

id integer

The ID of the attachment.

Body Parameters

description string

max.string.

name string

max.string.

privacy boolean

type string

max.string.

size string

max.string.

clinic_id integer

user_id integer

responsible_id integer

attachmentCategory_id integer

Delete an attachment

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/attachments/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/attachments/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/attachments/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachments/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Attachment Categories

APIs for managing attachment categories

Provide attachment categories (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/attachment-categories" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/attachment-categories"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/attachment-categories',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachment-categories'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store an attachment category

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/attachment-categories" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/attachment-categories"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/attachment-categories',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachment-categories'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide attachment categories

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/attachment-categories/all" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/attachment-categories/all"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/attachment-categories/all',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachment-categories/all'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide one attachment category

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/attachment-categories/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/attachment-categories/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/attachment-categories/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachment-categories/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update an attachment category

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/attachment-categories/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/attachment-categories/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/attachment-categories/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachment-categories/1'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete an attachment category

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/attachment-categories/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/attachment-categories/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/attachment-categories/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/attachment-categories/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Blood Glucose Records

APIs for managing blood glucose records

Provide blood glucose records between a given date

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/blood-glucoses" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"date_start\": \"2023-03-16T16:18:12\",
    \"date_end\": \"2023-03-16T16:18:12\"
}"

const url = new URL(
    "http://scan.test/api/blood-glucoses"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:12",
    "date_end": "2023-03-16T16:18:12"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/blood-glucoses',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'date_start' => '2023-03-16T16:18:12',
            'date_end' => '2023-03-16T16:18:12',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-glucoses'
payload = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:12",
    "date_end": "2023-03-16T16:18:12"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a blood glucose record

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/blood-glucoses" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"bs\": 108148.6455,
    \"date\": \"2023-03-16T16:18:12\"
}"

const url = new URL(
    "http://scan.test/api/blood-glucoses"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "bs": 108148.6455,
    "date": "2023-03-16T16:18:12"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/blood-glucoses',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'bs' => 108148.6455,
            'date' => '2023-03-16T16:18:12',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-glucoses'
payload = {
    "user_id": 9,
    "bs": 108148.6455,
    "date": "2023-03-16T16:18:12"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a blood glucose record

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/blood-glucoses/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/blood-glucoses/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/blood-glucoses/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-glucoses/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a blood glucose record

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/blood-glucoses/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"bs\": 108148.6455,
    \"date\": \"2023-03-16T16:18:12\",
    \"user_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/blood-glucoses/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "bs": 108148.6455,
    "date": "2023-03-16T16:18:12",
    "user_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/blood-glucoses/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'bs' => 108148.6455,
            'date' => '2023-03-16T16:18:12',
            'user_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-glucoses/9'
payload = {
    "bs": 108148.6455,
    "date": "2023-03-16T16:18:12",
    "user_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete a blood glucose record

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/blood-glucoses/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/blood-glucoses/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/blood-glucoses/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-glucoses/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Blood Groups

APIs for managing blood groups

Provide blood groups

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/blood-groups" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/blood-groups"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/blood-groups',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-groups'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store blood groups

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/blood-groups" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/blood-groups"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/blood-groups',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-groups'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a blood group

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/blood-groups/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/blood-groups/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/blood-groups/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-groups/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a blood group

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/blood-groups/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/blood-groups/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/blood-groups/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-groups/1'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete a blood group

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/blood-groups/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/blood-groups/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/blood-groups/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-groups/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Blood Pressure Records

APIs for managing blood pressure records

Provide blood pressure records between a given date

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/blood-pressures" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"date_start\": \"2023-03-16T16:18:12\",
    \"date_end\": \"2023-03-16T16:18:12\"
}"

const url = new URL(
    "http://scan.test/api/blood-pressures"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:12",
    "date_end": "2023-03-16T16:18:12"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/blood-pressures',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'date_start' => '2023-03-16T16:18:12',
            'date_end' => '2023-03-16T16:18:12',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-pressures'
payload = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:12",
    "date_end": "2023-03-16T16:18:12"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store blood pressure records

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/blood-pressures" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"sys\": 108148.6455,
    \"dia\": 108148.6455,
    \"pr\": 108148.6455,
    \"date\": \"2023-03-16T16:18:12\"
}"

const url = new URL(
    "http://scan.test/api/blood-pressures"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "sys": 108148.6455,
    "dia": 108148.6455,
    "pr": 108148.6455,
    "date": "2023-03-16T16:18:12"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/blood-pressures',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'sys' => 108148.6455,
            'dia' => 108148.6455,
            'pr' => 108148.6455,
            'date' => '2023-03-16T16:18:12',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-pressures'
payload = {
    "user_id": 9,
    "sys": 108148.6455,
    "dia": 108148.6455,
    "pr": 108148.6455,
    "date": "2023-03-16T16:18:12"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a blood pressure record

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/blood-pressures/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/blood-pressures/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/blood-pressures/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-pressures/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a blood pressure record

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/blood-pressures/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"sys\": 108148.6455,
    \"dia\": 108148.6455,
    \"pr\": 108148.6455,
    \"date\": \"2023-03-16T16:18:12\",
    \"user_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/blood-pressures/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sys": 108148.6455,
    "dia": 108148.6455,
    "pr": 108148.6455,
    "date": "2023-03-16T16:18:12",
    "user_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/blood-pressures/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'sys' => 108148.6455,
            'dia' => 108148.6455,
            'pr' => 108148.6455,
            'date' => '2023-03-16T16:18:12',
            'user_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-pressures/9'
payload = {
    "sys": 108148.6455,
    "dia": 108148.6455,
    "pr": 108148.6455,
    "date": "2023-03-16T16:18:12",
    "user_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/blood-pressures/{bloodpressure}

URL Parameters

bloodpressure integer

Body Parameters

sys number

dia number

pr number

date string

encontro.

user_id string

Delete a blood pressure record

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/blood-pressures/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/blood-pressures/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/blood-pressures/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/blood-pressures/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Brands

Provide brands (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/brands" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/brands"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/brands',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/brands'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a brand

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/brands" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ducimus\",
    \"observation\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/brands"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "ducimus",
    "observation": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/brands',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'ducimus',
            'observation' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/brands'
payload = {
    "name": "ducimus",
    "observation": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide brands

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/brands/all" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/brands/all"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/brands/all',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/brands/all'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide a brand

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/brands/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/brands/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/brands/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/brands/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a brand

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/brands/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ducimus\",
    \"observation\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/brands/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "ducimus",
    "observation": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/brands/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'ducimus',
            'observation' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/brands/9'
payload = {
    "name": "ducimus",
    "observation": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete a brand

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/brands/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/brands/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/brands/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/brands/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Clinics

APIs for Clinics

Provide allowed clinics (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/clinics" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/clinics"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/clinics',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a clinic

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/clinics" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ducimus\",
    \"address\": \"ducimus\",
    \"city\": \"ducimus\",
    \"email\": \"megane.corwin@example.org\",
    \"postcode\": \"ducimus\",
    \"latitude\": 17,
    \"longitude\": 78,
    \"website\": \"https:\\/\\/www.medhurst.info\\/id-vero-perspiciatis-nulla-nihil\",
    \"phone\": \"ducimus\",
    \"mobilephone\": \"ducimus\",
    \"tax_number\": \"ducimus\",
    \"observations\": \"ducimus\",
    \"country_id\": \"ducimus\",
    \"responsible_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/clinics"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "ducimus",
    "address": "ducimus",
    "city": "ducimus",
    "email": "megane.corwin@example.org",
    "postcode": "ducimus",
    "latitude": 17,
    "longitude": 78,
    "website": "https:\/\/www.medhurst.info\/id-vero-perspiciatis-nulla-nihil",
    "phone": "ducimus",
    "mobilephone": "ducimus",
    "tax_number": "ducimus",
    "observations": "ducimus",
    "country_id": "ducimus",
    "responsible_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/clinics',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'ducimus',
            'address' => 'ducimus',
            'city' => 'ducimus',
            'email' => 'megane.corwin@example.org',
            'postcode' => 'ducimus',
            'latitude' => 17,
            'longitude' => 78,
            'website' => 'https://www.medhurst.info/id-vero-perspiciatis-nulla-nihil',
            'phone' => 'ducimus',
            'mobilephone' => 'ducimus',
            'tax_number' => 'ducimus',
            'observations' => 'ducimus',
            'country_id' => 'ducimus',
            'responsible_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics'
payload = {
    "name": "ducimus",
    "address": "ducimus",
    "city": "ducimus",
    "email": "megane.corwin@example.org",
    "postcode": "ducimus",
    "latitude": 17,
    "longitude": 78,
    "website": "https:\/\/www.medhurst.info\/id-vero-perspiciatis-nulla-nihil",
    "phone": "ducimus",
    "mobilephone": "ducimus",
    "tax_number": "ducimus",
    "observations": "ducimus",
    "country_id": "ducimus",
    "responsible_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/clinics

Body Parameters

name string

address string

city string

email string optional

o email.

postcode string

latitude number

entre.numérico.

longitude number

entre.numérico.

website string optional

Must be a valid URL.

phone string

mobilephone string

tax_number string

observations string optional

country_id string

responsible_id string

Provide allowed clinics (non-paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/clinics/list" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/clinics/list"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/clinics/list',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/list'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Associate a collaborator to a clinic

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/clinics/associate-collaborator" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": \"ducimus\",
    \"perm\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/clinics/associate-collaborator"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": "ducimus",
    "perm": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/clinics/associate-collaborator',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 'ducimus',
            'perm' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/associate-collaborator'
payload = {
    "user_id": "ducimus",
    "perm": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Create and associate a Collaborator to a clinic

requires authentication

When a user is created an email is sent

Example request:

curl --request POST \
    "http://scan.test/api/clinics/associate-create-collaborator" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"megane.corwin@example.org\",
    \"mobilephone\": \"wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg\",
    \"first_name\": \"qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw\",
    \"last_name\": \"tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez\",
    \"full_name\": \"efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt\",
    \"username\": \"rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan\",
    \"perm\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/clinics/associate-create-collaborator"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "megane.corwin@example.org",
    "mobilephone": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "first_name": "qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw",
    "last_name": "tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez",
    "full_name": "efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt",
    "username": "rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan",
    "perm": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/clinics/associate-create-collaborator',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'megane.corwin@example.org',
            'mobilephone' => 'wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg',
            'first_name' => 'qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw',
            'last_name' => 'tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez',
            'full_name' => 'efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt',
            'username' => 'rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan',
            'perm' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/associate-create-collaborator'
payload = {
    "email": "megane.corwin@example.org",
    "mobilephone": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "first_name": "qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw",
    "last_name": "tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez",
    "full_name": "efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt",
    "username": "rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan",
    "perm": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/clinics/associate-create-collaborator

Body Parameters

email string

o email.

mobilephone string

max.string.

first_name string

max.string.

last_name string

max.string.

full_name string

max.string.

username string

max.string.

perm string

Associate a patient to a clinic

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/clinics/associate-patient" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"clinic_default_id\": 9
}"

const url = new URL(
    "http://scan.test/api/clinics/associate-patient"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "clinic_default_id": 9
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/clinics/associate-patient',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'clinic_default_id' => 9,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/associate-patient'
payload = {
    "user_id": 9,
    "clinic_default_id": 9
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Create and associate a patient to a clinic

requires authentication

When a user is created an email is sent

Example request:

curl --request POST \
    "http://scan.test/api/clinics/associate-create-patient" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"megane.corwin@example.org\",
    \"mobilephone\": \"wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg\",
    \"first_name\": \"qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw\",
    \"last_name\": \"tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez\",
    \"full_name\": \"efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt\",
    \"username\": \"rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan\",
    \"clinic_default_id\": 9
}"

const url = new URL(
    "http://scan.test/api/clinics/associate-create-patient"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "megane.corwin@example.org",
    "mobilephone": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "first_name": "qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw",
    "last_name": "tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez",
    "full_name": "efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt",
    "username": "rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan",
    "clinic_default_id": 9
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/clinics/associate-create-patient',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'megane.corwin@example.org',
            'mobilephone' => 'wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg',
            'first_name' => 'qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw',
            'last_name' => 'tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez',
            'full_name' => 'efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt',
            'username' => 'rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan',
            'clinic_default_id' => 9,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/associate-create-patient'
payload = {
    "email": "megane.corwin@example.org",
    "mobilephone": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "first_name": "qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw",
    "last_name": "tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez",
    "full_name": "efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt",
    "username": "rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan",
    "clinic_default_id": 9
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/clinics/associate-create-patient

Body Parameters

email string

o email.

mobilephone string

max.string.

first_name string

max.string.

last_name string

max.string.

full_name string

max.string.

username string

max.string.

clinic_default_id integer

Provide a clinic

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/clinics/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/clinics/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/clinics/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide collaborators of a specific clinic

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/clinics/collab/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/clinics/collab/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/clinics/collab/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/collab/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide patients of a specific clinic

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/clinics/patient/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/clinics/patient/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/clinics/patient/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/patient/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Get the clinic contacts

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/clinics/contacts/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/clinics/contacts/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/clinics/contacts/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/contacts/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Get the clinic observations

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/clinics/observations/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/clinics/observations/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/clinics/observations/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/observations/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a clinic

requires authentication

Example request:

curl --request PUT \
    "http://scan.test/api/clinics/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"country_id\": \"ducimus\",
    \"address\": \"psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt\",
    \"city\": \"pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe\",
    \"postcode\": \"kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny\",
    \"latitude\": 29,
    \"longitude\": -108,
    \"website\": \"ezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuyth\",
    \"phone\": \"dtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfa\",
    \"mobilephone\": \"angnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmhif\",
    \"observations\": \"fhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahpvp\",
    \"tax_number\": \"nexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadhpy\",
    \"email\": \"megane.corwin@example.org\",
    \"responsible_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/clinics/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "country_id": "ducimus",
    "address": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "city": "pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe",
    "postcode": "kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny",
    "latitude": 29,
    "longitude": -108,
    "website": "ezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuyth",
    "phone": "dtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfa",
    "mobilephone": "angnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmhif",
    "observations": "fhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahpvp",
    "tax_number": "nexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadhpy",
    "email": "megane.corwin@example.org",
    "responsible_id": "ducimus"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://scan.test/api/clinics/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'country_id' => 'ducimus',
            'address' => 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt',
            'city' => 'pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe',
            'postcode' => 'kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny',
            'latitude' => 29,
            'longitude' => -108,
            'website' => 'ezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuyth',
            'phone' => 'dtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfa',
            'mobilephone' => 'angnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmhif',
            'observations' => 'fhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahpvp',
            'tax_number' => 'nexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadhpy',
            'email' => 'megane.corwin@example.org',
            'responsible_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/9'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "country_id": "ducimus",
    "address": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "city": "pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe",
    "postcode": "kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny",
    "latitude": 29,
    "longitude": -108,
    "website": "ezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuyth",
    "phone": "dtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfa",
    "mobilephone": "angnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmhif",
    "observations": "fhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahpvp",
    "tax_number": "nexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadhpy",
    "email": "megane.corwin@example.org",
    "responsible_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PUT api/clinics/{id}

URL Parameters

id integer

The ID of the clinic.

Body Parameters

name string

max.string.

country_id string

address string optional

max.string.

city string optional

max.string.

postcode string optional

max.string.

latitude number optional

entre.numérico.

longitude number optional

entre.numérico.

website string optional

max.string.

phone string optional

max.string.

mobilephone string optional

max.string.

observations string optional

max.string.

tax_number string optional

max.string.

email string optional

o email.

responsible_id string

Delete a clinic

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/clinics/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/clinics/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/clinics/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/clinics/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Contacts

APIs for managing contacts

Provide contacts (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/contacts" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/contacts"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/contacts',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/contacts'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a contact

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/contacts" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"phone\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\",
    \"email\": \"megane.corwin@example.org\",
    \"observation\": \"wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg\",
    \"functionRole_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/contacts"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "phone": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "email": "megane.corwin@example.org",
    "observation": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "functionRole_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/contacts',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'phone' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
            'email' => 'megane.corwin@example.org',
            'observation' => 'wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg',
            'functionRole_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/contacts'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "phone": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "email": "megane.corwin@example.org",
    "observation": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "functionRole_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/contacts

Body Parameters

name string

max.string.

phone string

max.string.

email string

o email.

observation string optional

max.string.

user_id string optional

necessário_se.

clinic_id string optional

necessário_se.

functionRole_id string

Provide contact

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/contacts/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/contacts/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/contacts/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/contacts/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a contact

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/contacts/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"phone\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\",
    \"email\": \"megane.corwin@example.org\",
    \"observation\": \"wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg\",
    \"functionRole_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/contacts/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "phone": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "email": "megane.corwin@example.org",
    "observation": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "functionRole_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/contacts/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'phone' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
            'email' => 'megane.corwin@example.org',
            'observation' => 'wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg',
            'functionRole_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/contacts/9'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "phone": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "email": "megane.corwin@example.org",
    "observation": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "functionRole_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/contacts/{id}

URL Parameters

id integer

The ID of the contact.

Body Parameters

name string

max.string.

phone string

max.string.

email string

o email.

observation string optional

max.string.

user_id string optional

necessário_se.

clinic_id string optional

necessário_se.

functionRole_id string

Delete a contact

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/contacts/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/contacts/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/contacts/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/contacts/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Countries

APIs for Countries

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/countries" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/countries"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/countries',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/countries'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/countries" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/countries"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/countries',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/countries'
payload = {
    "name": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Display the specified resource.

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/countries/4" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/countries/4"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/countries/4',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/countries/4'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update the specified resource in storage.

requires authentication

Example request:

curl --request PUT \
    "http://scan.test/api/countries/4" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/countries/4"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "ducimus"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://scan.test/api/countries/4',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/countries/4'
payload = {
    "name": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/countries/4" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/countries/4"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/countries/4',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/countries/4'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Daily Check Records

APIs for managing daily cheks

Provide daily checks records (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/daily-checks" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"date_start\": \"2023-03-16T16:18:11\",
    \"date_end\": \"2023-03-16T16:18:11\"
}"

const url = new URL(
    "http://scan.test/api/daily-checks"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:11",
    "date_end": "2023-03-16T16:18:11"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/daily-checks',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'date_start' => '2023-03-16T16:18:11',
            'date_end' => '2023-03-16T16:18:11',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/daily-checks'
payload = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:11",
    "date_end": "2023-03-16T16:18:11"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a daily checks record

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/daily-checks" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"hr\": 108148.6455,
    \"pi\": 108148.6455,
    \"graphic_data\": [
        \"ducimus\"
    ],
    \"date\": \"2023-03-16T16:18:11\",
    \"oxy\": 108148.6455,
    \"pr\": 108148.6455,
    \"st\": 108148.6455,
    \"qrs\": 108148.6455,
    \"pvcs\": 108148.6455,
    \"qtc\": 108148.6455,
    \"qt\": 108148.6455
}"

const url = new URL(
    "http://scan.test/api/daily-checks"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "hr": 108148.6455,
    "pi": 108148.6455,
    "graphic_data": [
        "ducimus"
    ],
    "date": "2023-03-16T16:18:11",
    "oxy": 108148.6455,
    "pr": 108148.6455,
    "st": 108148.6455,
    "qrs": 108148.6455,
    "pvcs": 108148.6455,
    "qtc": 108148.6455,
    "qt": 108148.6455
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/daily-checks',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'hr' => 108148.6455,
            'pi' => 108148.6455,
            'graphic_data' => [
                'ducimus',
            ],
            'date' => '2023-03-16T16:18:11',
            'oxy' => 108148.6455,
            'pr' => 108148.6455,
            'st' => 108148.6455,
            'qrs' => 108148.6455,
            'pvcs' => 108148.6455,
            'qtc' => 108148.6455,
            'qt' => 108148.6455,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/daily-checks'
payload = {
    "user_id": 9,
    "hr": 108148.6455,
    "pi": 108148.6455,
    "graphic_data": [
        "ducimus"
    ],
    "date": "2023-03-16T16:18:11",
    "oxy": 108148.6455,
    "pr": 108148.6455,
    "st": 108148.6455,
    "qrs": 108148.6455,
    "pvcs": 108148.6455,
    "qtc": 108148.6455,
    "qt": 108148.6455
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/daily-checks

Body Parameters

user_id integer optional

hr number

pi number

graphic_data string[] optional

date string

encontro.

oxy number

pr number

st number

qrs number

pvcs number

qtc number

qt number

Provide a daily check record

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/daily-checks/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/daily-checks/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/daily-checks/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/daily-checks/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a daily check record

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/daily-checks/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"hr\": 108148.6455,
    \"pi\": 108148.6455,
    \"graphic_data\": \"ducimus\",
    \"date\": \"2023-03-16T16:18:11\",
    \"oxy\": 108148.6455,
    \"pr\": 108148.6455,
    \"st\": 108148.6455,
    \"qrs\": 108148.6455,
    \"pvcs\": 108148.6455,
    \"qtc\": 108148.6455,
    \"qt\": 108148.6455
}"

const url = new URL(
    "http://scan.test/api/daily-checks/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "hr": 108148.6455,
    "pi": 108148.6455,
    "graphic_data": "ducimus",
    "date": "2023-03-16T16:18:11",
    "oxy": 108148.6455,
    "pr": 108148.6455,
    "st": 108148.6455,
    "qrs": 108148.6455,
    "pvcs": 108148.6455,
    "qtc": 108148.6455,
    "qt": 108148.6455
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/daily-checks/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'hr' => 108148.6455,
            'pi' => 108148.6455,
            'graphic_data' => 'ducimus',
            'date' => '2023-03-16T16:18:11',
            'oxy' => 108148.6455,
            'pr' => 108148.6455,
            'st' => 108148.6455,
            'qrs' => 108148.6455,
            'pvcs' => 108148.6455,
            'qtc' => 108148.6455,
            'qt' => 108148.6455,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/daily-checks/9'
payload = {
    "hr": 108148.6455,
    "pi": 108148.6455,
    "graphic_data": "ducimus",
    "date": "2023-03-16T16:18:11",
    "oxy": 108148.6455,
    "pr": 108148.6455,
    "st": 108148.6455,
    "qrs": 108148.6455,
    "pvcs": 108148.6455,
    "qtc": 108148.6455,
    "qt": 108148.6455
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/daily-checks/{dailycheck}

URL Parameters

dailycheck integer

Body Parameters

hr number

pi number

graphic_data string optional

date string

encontro.

oxy number

pr number

st number

qrs number

pvcs number

qtc number

qt number

Delete a daily check record

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/daily-checks/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/daily-checks/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/daily-checks/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/daily-checks/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Departments

APIs for managing departments

Provide departments (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/departments" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/departments"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/departments',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/departments'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a department

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/departments" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"code\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\"
}"

const url = new URL(
    "http://scan.test/api/departments"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/departments',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'code' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/departments'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a department

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/departments/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/departments/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/departments/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/departments/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a department

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/departments/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"code\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\"
}"

const url = new URL(
    "http://scan.test/api/departments/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/departments/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'code' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/departments/9'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete a department

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/departments/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/departments/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/departments/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/departments/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Device Model

APIs for managing devices

Provide device models

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/device-models/all" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/device-models/all"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/device-models/all',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/device-models/all'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide device models (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/device-models" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/device-models"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/device-models',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/device-models'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a device model

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/device-models" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"brand_id\": \"ducimus\",
    \"observation\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/device-models"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "brand_id": "ducimus",
    "observation": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/device-models',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'brand_id' => 'ducimus',
            'observation' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/device-models'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "brand_id": "ducimus",
    "observation": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a device model

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/device-models/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/device-models/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/device-models/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/device-models/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a device model

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/device-models/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"brand_id\": \"ducimus\",
    \"observation\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/device-models/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "brand_id": "ducimus",
    "observation": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/device-models/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'brand_id' => 'ducimus',
            'observation' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/device-models/9'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "brand_id": "ducimus",
    "observation": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/device-models/{devicemodel_id}

URL Parameters

devicemodel_id integer

The ID of the devicemodel.

Body Parameters

name string

max.string.

brand_id string

observation string optional

Delete a device model

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/device-models/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/device-models/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/device-models/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/device-models/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Devices

APIs for managing devices

Provide devices (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/devices" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/devices"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/devices',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/devices'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a device

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/devices" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"mac_address\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"device_model_id\": \"ducimus\",
    \"clinic_id\": \"ducimus\",
    \"observation\": \"psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt\"
}"

const url = new URL(
    "http://scan.test/api/devices"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "mac_address": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "device_model_id": "ducimus",
    "clinic_id": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/devices',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'mac_address' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'device_model_id' => 'ducimus',
            'clinic_id' => 'ducimus',
            'observation' => 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/devices'
payload = {
    "mac_address": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "device_model_id": "ducimus",
    "clinic_id": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a department

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/devices/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/devices/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/devices/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/devices/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a department

requires authentication

Example request:

curl --request PUT \
    "http://scan.test/api/devices/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"mac_address\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"device_model_id\": \"ducimus\",
    \"observation\": \"psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt\"
}"

const url = new URL(
    "http://scan.test/api/devices/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "mac_address": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "device_model_id": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://scan.test/api/devices/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'mac_address' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'device_model_id' => 'ducimus',
            'observation' => 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/devices/9'
payload = {
    "mac_address": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "device_model_id": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PUT api/devices/{id}

PATCH api/devices/{id}

URL Parameters

id integer

The ID of the device.

Body Parameters

mac_address string

max.string.

device_model_id string

observation string optional

max.string.

Delete a device

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/devices/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/devices/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/devices/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/devices/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Ecg Records

APIs for managing ecg records

Provide ecg records (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/ecgs" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"date_start\": \"2023-03-16T16:18:11\",
    \"date_end\": \"2023-03-16T16:18:11\"
}"

const url = new URL(
    "http://scan.test/api/ecgs"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:11",
    "date_end": "2023-03-16T16:18:11"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/ecgs',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'date_start' => '2023-03-16T16:18:11',
            'date_end' => '2023-03-16T16:18:11',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/ecgs'
payload = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:11",
    "date_end": "2023-03-16T16:18:11"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store an ecg record

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/ecgs" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"hr\": 108148.6455,
    \"qrs\": 108148.6455,
    \"qt\": 108148.6455,
    \"qtc\": 108148.6455,
    \"st\": 108148.6455,
    \"pvcs\": 108148.6455,
    \"graphic_data\": [
        \"ducimus\"
    ],
    \"date\": \"2023-03-16T16:18:11\"
}"

const url = new URL(
    "http://scan.test/api/ecgs"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "hr": 108148.6455,
    "qrs": 108148.6455,
    "qt": 108148.6455,
    "qtc": 108148.6455,
    "st": 108148.6455,
    "pvcs": 108148.6455,
    "graphic_data": [
        "ducimus"
    ],
    "date": "2023-03-16T16:18:11"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/ecgs',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'hr' => 108148.6455,
            'qrs' => 108148.6455,
            'qt' => 108148.6455,
            'qtc' => 108148.6455,
            'st' => 108148.6455,
            'pvcs' => 108148.6455,
            'graphic_data' => [
                'ducimus',
            ],
            'date' => '2023-03-16T16:18:11',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/ecgs'
payload = {
    "user_id": 9,
    "hr": 108148.6455,
    "qrs": 108148.6455,
    "qt": 108148.6455,
    "qtc": 108148.6455,
    "st": 108148.6455,
    "pvcs": 108148.6455,
    "graphic_data": [
        "ducimus"
    ],
    "date": "2023-03-16T16:18:11"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/ecgs

Body Parameters

user_id integer optional

hr number

qrs number

qt number

qtc number

st number

pvcs number

graphic_data string[]

date string

encontro.

Provide an ecg record

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/ecgs/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/ecgs/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/ecgs/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/ecgs/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update an ecg record

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/ecgs/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"hr\": 108148.6455,
    \"qrs\": 108148.6455,
    \"qt\": 108148.6455,
    \"qtc\": 108148.6455,
    \"st\": 108148.6455,
    \"pvcs\": 108148.6455,
    \"graphic_data\": \"ducimus\",
    \"date\": \"2023-03-16T16:18:11\",
    \"user_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/ecgs/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "hr": 108148.6455,
    "qrs": 108148.6455,
    "qt": 108148.6455,
    "qtc": 108148.6455,
    "st": 108148.6455,
    "pvcs": 108148.6455,
    "graphic_data": "ducimus",
    "date": "2023-03-16T16:18:11",
    "user_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/ecgs/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'hr' => 108148.6455,
            'qrs' => 108148.6455,
            'qt' => 108148.6455,
            'qtc' => 108148.6455,
            'st' => 108148.6455,
            'pvcs' => 108148.6455,
            'graphic_data' => 'ducimus',
            'date' => '2023-03-16T16:18:11',
            'user_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/ecgs/9'
payload = {
    "hr": 108148.6455,
    "qrs": 108148.6455,
    "qt": 108148.6455,
    "qtc": 108148.6455,
    "st": 108148.6455,
    "pvcs": 108148.6455,
    "graphic_data": "ducimus",
    "date": "2023-03-16T16:18:11",
    "user_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/ecgs/{id}

URL Parameters

id integer

The ID of the ecg.

Body Parameters

hr number

qrs number

qt number

qtc number

st number

pvcs number

graphic_data string optional

date string

encontro.

user_id string

Delete an ecg record

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/ecgs/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/ecgs/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/ecgs/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/ecgs/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Email Templates

APIs for managing email templates

Provide emails templates (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/email-templates/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/email-templates/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/email-templates/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-templates/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store an email template

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/email-templates" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"subject\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"content\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\"
}"

const url = new URL(
    "http://scan.test/api/email-templates"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "content": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/email-templates',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'subject' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'content' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-templates'
payload = {
    "subject": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "content": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide an email template

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/email-templates/show/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/email-templates/show/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/email-templates/show/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-templates/show/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update an email template

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/email-templates/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"content\": \"ducimus\",
    \"clinic_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/email-templates/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "content": "ducimus",
    "clinic_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/email-templates/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'content' => 'ducimus',
            'clinic_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-templates/1'
payload = {
    "content": "ducimus",
    "clinic_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete an email template

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/email-templates/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/email-templates/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/email-templates/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-templates/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Test an email template

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/email-templates/test" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"subject\": \"lpsdpwowlqjpohcbat\",
    \"value\": \"ducimus\",
    \"clinic_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/email-templates/test"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject": "lpsdpwowlqjpohcbat",
    "value": "ducimus",
    "clinic_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/email-templates/test',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'subject' => 'lpsdpwowlqjpohcbat',
            'value' => 'ducimus',
            'clinic_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-templates/test'
payload = {
    "subject": "lpsdpwowlqjpohcbat",
    "value": "ducimus",
    "clinic_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Restore a template

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/email-templates/reset-default" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"subject\": \"lpsdpwowlqjpohcbat\",
    \"template_id\": \"ducimus\",
    \"clinic_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/email-templates/reset-default"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject": "lpsdpwowlqjpohcbat",
    "template_id": "ducimus",
    "clinic_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/email-templates/reset-default',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'subject' => 'lpsdpwowlqjpohcbat',
            'template_id' => 'ducimus',
            'clinic_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-templates/reset-default'
payload = {
    "subject": "lpsdpwowlqjpohcbat",
    "template_id": "ducimus",
    "clinic_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Emails sended

APIs for managing sended emails

Provide emails sended (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/email-sended" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/email-sended"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/email-sended',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-sended'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store an email sended

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/email-sended" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"sent\": false,
    \"clinic_id\": \"ducimus\",
    \"emailTemplate_id\": \"ducimus\",
    \"user_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/email-sended"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sent": false,
    "clinic_id": "ducimus",
    "emailTemplate_id": "ducimus",
    "user_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/email-sended',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'sent' => false,
            'clinic_id' => 'ducimus',
            'emailTemplate_id' => 'ducimus',
            'user_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-sended'
payload = {
    "sent": false,
    "clinic_id": "ducimus",
    "emailTemplate_id": "ducimus",
    "user_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide an email sended

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/email-sended/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/email-sended/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/email-sended/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-sended/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update an email sended

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/email-sended/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"sent\": false,
    \"clinic_id\": \"ducimus\",
    \"emailTemplate_id\": \"ducimus\",
    \"user_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/email-sended/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sent": false,
    "clinic_id": "ducimus",
    "emailTemplate_id": "ducimus",
    "user_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/email-sended/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'sent' => false,
            'clinic_id' => 'ducimus',
            'emailTemplate_id' => 'ducimus',
            'user_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-sended/9'
payload = {
    "sent": false,
    "clinic_id": "ducimus",
    "emailTemplate_id": "ducimus",
    "user_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/email-sended/{emailsended}

URL Parameters

emailsended integer

Body Parameters

sent boolean

clinic_id string

emailTemplate_id string

user_id string

Delete an email sended

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/email-sended/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/email-sended/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/email-sended/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/email-sended/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Function/Roles

APIs for managing function/roles

Provide functions/roles (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/function-roles" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/function-roles"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/function-roles',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/function-roles'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide functions/roles (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/function-roles/get-all" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/function-roles/get-all"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/function-roles/get-all',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/function-roles/get-all'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a function/role

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/function-roles" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/function-roles"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/function-roles',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/function-roles'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a function/role

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/function-roles/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/function-roles/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/function-roles/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/function-roles/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a function/role

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/function-roles/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/function-roles/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/function-roles/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/function-roles/1'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete a function/role

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/function-roles/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/function-roles/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/function-roles/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/function-roles/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Medical Health Records

APIs for managing medical health records

Provide a medical health record

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/medical-health-records/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/medical-health-records/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/medical-health-records/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medical-health-records/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a medical health record

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/medical-health-records" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"description\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"height\": 108148.6455,
    \"another_pathologies\": \"pwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmm\",
    \"pathologies\": [
        \"ducimus\"
    ],
    \"medical_center_name\": \"psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt\",
    \"medical_center_assistant_doctor\": \"pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe\",
    \"medical_center_postcode\": \"kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny\",
    \"medical_center_address\": \"rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy\",
    \"medical_center_contact\": \"thdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdw\",
    \"external_doctor_name\": \"faangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmh\",
    \"external_doctor_address\": \"iffhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahp\",
    \"external_doctor_postcode\": \"vpnexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadh\",
    \"external_doctor_contact\": \"pyegkjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcv\",
    \"food_cares\": \"gqsljixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuic\",
    \"allergies\": \"dlqyewgueorcecquzlvcqvylqexlrtwhlegearvmxqlofgnocgnwdsddtngeioylhkpdimphjtxnljeerbigikqeevcriexwzghpfmoxitkfhargda\",
    \"diseases\": \"tfpcpzjexpjaqnnreszbbzqbtkncesklhthjvkuhycunnubexmlfcmftzywjvmjpnukjfkgtdiyzpsazbtthriyomgzxntaoonsgypzvcbysyfbfii\",
    \"operations\": \"pocrnnzbxcttfxgdlyskwidysjxrhdjxqiaudwdugquzczdrzjqzerotbbmuexinaszbcxrhostyxgddplockssfwmsinqzpfviwhxbfyfgjauymbz\",
    \"dependencies\": \"mxofmkfzyfmlocvaweedbgbesiwwfnwwczgromthccoapzmefrebmjvrondcfmxczbslghcyzupeclqxqlaolpesfwdedsrqzpwwyyknpbvezfhxon\",
    \"special_cares\": \"ellloesncmniyuewpwbadgytrjlhngemmecgtkuqvknjmfsogwwkientoadvoxtgadzwcoodpcgkcnsvtwmqgxssplqsffpljyugsvircfjxwgpopi\"
}"

const url = new URL(
    "http://scan.test/api/medical-health-records"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "description": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "height": 108148.6455,
    "another_pathologies": "pwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmm",
    "pathologies": [
        "ducimus"
    ],
    "medical_center_name": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "medical_center_assistant_doctor": "pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe",
    "medical_center_postcode": "kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny",
    "medical_center_address": "rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy",
    "medical_center_contact": "thdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdw",
    "external_doctor_name": "faangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmh",
    "external_doctor_address": "iffhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahp",
    "external_doctor_postcode": "vpnexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadh",
    "external_doctor_contact": "pyegkjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcv",
    "food_cares": "gqsljixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuic",
    "allergies": "dlqyewgueorcecquzlvcqvylqexlrtwhlegearvmxqlofgnocgnwdsddtngeioylhkpdimphjtxnljeerbigikqeevcriexwzghpfmoxitkfhargda",
    "diseases": "tfpcpzjexpjaqnnreszbbzqbtkncesklhthjvkuhycunnubexmlfcmftzywjvmjpnukjfkgtdiyzpsazbtthriyomgzxntaoonsgypzvcbysyfbfii",
    "operations": "pocrnnzbxcttfxgdlyskwidysjxrhdjxqiaudwdugquzczdrzjqzerotbbmuexinaszbcxrhostyxgddplockssfwmsinqzpfviwhxbfyfgjauymbz",
    "dependencies": "mxofmkfzyfmlocvaweedbgbesiwwfnwwczgromthccoapzmefrebmjvrondcfmxczbslghcyzupeclqxqlaolpesfwdedsrqzpwwyyknpbvezfhxon",
    "special_cares": "ellloesncmniyuewpwbadgytrjlhngemmecgtkuqvknjmfsogwwkientoadvoxtgadzwcoodpcgkcnsvtwmqgxssplqsffpljyugsvircfjxwgpopi"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/medical-health-records',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'description' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'height' => 108148.6455,
            'another_pathologies' => 'pwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmm',
            'pathologies' => [
                'ducimus',
            ],
            'medical_center_name' => 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt',
            'medical_center_assistant_doctor' => 'pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe',
            'medical_center_postcode' => 'kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny',
            'medical_center_address' => 'rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy',
            'medical_center_contact' => 'thdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdw',
            'external_doctor_name' => 'faangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmh',
            'external_doctor_address' => 'iffhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahp',
            'external_doctor_postcode' => 'vpnexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadh',
            'external_doctor_contact' => 'pyegkjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcv',
            'food_cares' => 'gqsljixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuic',
            'allergies' => 'dlqyewgueorcecquzlvcqvylqexlrtwhlegearvmxqlofgnocgnwdsddtngeioylhkpdimphjtxnljeerbigikqeevcriexwzghpfmoxitkfhargda',
            'diseases' => 'tfpcpzjexpjaqnnreszbbzqbtkncesklhthjvkuhycunnubexmlfcmftzywjvmjpnukjfkgtdiyzpsazbtthriyomgzxntaoonsgypzvcbysyfbfii',
            'operations' => 'pocrnnzbxcttfxgdlyskwidysjxrhdjxqiaudwdugquzczdrzjqzerotbbmuexinaszbcxrhostyxgddplockssfwmsinqzpfviwhxbfyfgjauymbz',
            'dependencies' => 'mxofmkfzyfmlocvaweedbgbesiwwfnwwczgromthccoapzmefrebmjvrondcfmxczbslghcyzupeclqxqlaolpesfwdedsrqzpwwyyknpbvezfhxon',
            'special_cares' => 'ellloesncmniyuewpwbadgytrjlhngemmecgtkuqvknjmfsogwwkientoadvoxtgadzwcoodpcgkcnsvtwmqgxssplqsffpljyugsvircfjxwgpopi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medical-health-records'
payload = {
    "description": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "height": 108148.6455,
    "another_pathologies": "pwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmm",
    "pathologies": [
        "ducimus"
    ],
    "medical_center_name": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "medical_center_assistant_doctor": "pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe",
    "medical_center_postcode": "kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny",
    "medical_center_address": "rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy",
    "medical_center_contact": "thdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdw",
    "external_doctor_name": "faangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmh",
    "external_doctor_address": "iffhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahp",
    "external_doctor_postcode": "vpnexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadh",
    "external_doctor_contact": "pyegkjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcv",
    "food_cares": "gqsljixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuic",
    "allergies": "dlqyewgueorcecquzlvcqvylqexlrtwhlegearvmxqlofgnocgnwdsddtngeioylhkpdimphjtxnljeerbigikqeevcriexwzghpfmoxitkfhargda",
    "diseases": "tfpcpzjexpjaqnnreszbbzqbtkncesklhthjvkuhycunnubexmlfcmftzywjvmjpnukjfkgtdiyzpsazbtthriyomgzxntaoonsgypzvcbysyfbfii",
    "operations": "pocrnnzbxcttfxgdlyskwidysjxrhdjxqiaudwdugquzczdrzjqzerotbbmuexinaszbcxrhostyxgddplockssfwmsinqzpfviwhxbfyfgjauymbz",
    "dependencies": "mxofmkfzyfmlocvaweedbgbesiwwfnwwczgromthccoapzmefrebmjvrondcfmxczbslghcyzupeclqxqlaolpesfwdedsrqzpwwyyknpbvezfhxon",
    "special_cares": "ellloesncmniyuewpwbadgytrjlhngemmecgtkuqvknjmfsogwwkientoadvoxtgadzwcoodpcgkcnsvtwmqgxssplqsffpljyugsvircfjxwgpopi"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/medical-health-records

Body Parameters

description string optional

max.string.

height number optional

another_pathologies string optional

max.string.

pathologies string[] optional

medical_center_name string optional

max.string.

medical_center_assistant_doctor string optional

max.string.

medical_center_postcode string optional

max.string.

medical_center_address string optional

max.string.

medical_center_contact string optional

max.string.

external_doctor_name string optional

max.string.

external_doctor_address string optional

max.string.

external_doctor_postcode string optional

max.string.

external_doctor_contact string optional

max.string.

food_cares string optional

max.string.

allergies string optional

max.string.

diseases string optional

max.string.

operations string optional

max.string.

dependencies string optional

max.string.

special_cares string optional

max.string.

Medication Types

APIs for managing medication types

Store a password request

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/new-password" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"megane.corwin@example.org\"
}"

const url = new URL(
    "http://scan.test/api/new-password"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "megane.corwin@example.org"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/new-password',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'megane.corwin@example.org',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/new-password'
payload = {
    "email": "megane.corwin@example.org"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Store a password request

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/new-password/verify" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"token\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/new-password/verify"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "token": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/new-password/verify',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'token' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/new-password/verify'
payload = {
    "token": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Submit a new password

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/new-password/submit-password" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"megane.corwin@example.org\",
    \"password\": \"wo\",
    \"password_confirmation\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/new-password/submit-password"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "email": "megane.corwin@example.org",
    "password": "wo",
    "password_confirmation": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/new-password/submit-password',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => 'megane.corwin@example.org',
            'password' => 'wo',
            'password_confirmation' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/new-password/submit-password'
payload = {
    "email": "megane.corwin@example.org",
    "password": "wo",
    "password_confirmation": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide medication types (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/medication-types" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/medication-types"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/medication-types',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medication-types'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide medication types (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/medication-types/all" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/medication-types/all"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/medication-types/all',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medication-types/all'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a medication type

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/medication-types" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"code\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\"
}"

const url = new URL(
    "http://scan.test/api/medication-types"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/medication-types',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'code' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medication-types'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a medication type

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/medication-types/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/medication-types/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/medication-types/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medication-types/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a medication type

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/medication-types/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"code\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\"
}"

const url = new URL(
    "http://scan.test/api/medication-types/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/medication-types/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'code' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medication-types/1'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete a medication type

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/medication-types/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/medication-types/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/medication-types/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medication-types/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Medications

APIs for managing medications

Provide medications (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/medications" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/medications"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/medications',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medications'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide medications

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/medications/all" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/medications/all"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/medications/all',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medications/all'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a medication

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/medications" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"description\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\",
    \"dosage\": 0,
    \"dosage_unit\": \"ducimus\",
    \"frequency\": \"ducimus\",
    \"frequency_unit\": \"ducimus\",
    \"observation\": \"psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt\",
    \"medicationType_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/medications"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "description": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "dosage": 0,
    "dosage_unit": "ducimus",
    "frequency": "ducimus",
    "frequency_unit": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "medicationType_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/medications',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'description' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
            'dosage' => 0,
            'dosage_unit' => 'ducimus',
            'frequency' => 'ducimus',
            'frequency_unit' => 'ducimus',
            'observation' => 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt',
            'medicationType_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medications'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "description": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "dosage": 0,
    "dosage_unit": "ducimus",
    "frequency": "ducimus",
    "frequency_unit": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "medicationType_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/medications

Body Parameters

name string

max.string.

description string optional

max.string.

dosage number

min.numérico.

dosage_unit string

(allowed) AMPOULE, APPLICATION, SPOON, PILL, CAPSULE, DRAGEIA, DROP, INHALATION, INJECTION, MILLILITER, NEBULIZATION, PASTILLE, PILULE, SEAL, SUPPOSITORY, OVULE, SACHET.

frequency string

(allowed) ONE_IN_ONE, TWO_IN_TWO, THREE_IN_THREE, FOUR_IN_FOUR, FIVE_IN_FIVE, SIX_IN_SIX, SEVEN_IN_SEVEN, EIGHT_IN_EIGHT, NINE_IN_NINE, TEN_IN_TEN, ELEVEN_IN_ELEVEN, TWELVE_IN_TWELVE, THIRTEEN_IN_THIRTEEN, FOURTEEN_IN_FOURTEEN, FIFTEEN_IN_FIFTEEN, SIXTEEN_IN_SIXTEEN, SEVENTEEN_IN_SEVENTEEN, EIGHTEEN_IN_EIGHTEEN, NINETEEN_IN_NINETEEN, TWENTY_IN_TWENTY, TWENTY_ONE_IN_TWENTY_ONE, TWENTY_TWO_IN_TWENTY_TWO, TWENTY_THREE_IN_TWENTY_THREE, TWENTY_FOUR_IN_TWENTY_FOUR.

frequency_unit string

(allowed) HOUR.

observation string optional

max.string.

medicationType_id string

Provide a medication

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/medications/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/medications/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/medications/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medications/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a medication

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/medications/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"description\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\",
    \"dosage\": 0,
    \"dosage_unit\": \"ducimus\",
    \"frequency\": \"ducimus\",
    \"frequency_unit\": \"ducimus\",
    \"observation\": \"psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt\",
    \"medicationType_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/medications/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "description": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "dosage": 0,
    "dosage_unit": "ducimus",
    "frequency": "ducimus",
    "frequency_unit": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "medicationType_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/medications/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'description' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
            'dosage' => 0,
            'dosage_unit' => 'ducimus',
            'frequency' => 'ducimus',
            'frequency_unit' => 'ducimus',
            'observation' => 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt',
            'medicationType_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medications/9'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "description": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "dosage": 0,
    "dosage_unit": "ducimus",
    "frequency": "ducimus",
    "frequency_unit": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "medicationType_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/medications/{id}

URL Parameters

id integer

The ID of the medication.

Body Parameters

name string

max.string.

description string optional

max.string.

dosage number

min.numérico.

dosage_unit string

(allowed) AMPOULE, APPLICATION, SPOON, PILL, CAPSULE, DRAGEIA, DROP, INHALATION, INJECTION, MILLILITER, NEBULIZATION, PASTILLE, PILULE, SEAL, SUPPOSITORY, OVULE, SACHET.

frequency string

frequency_unit string

(allowed) HOUR.

observation string optional

max.string.

medicationType_id string

Delete a medication

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/medications/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/medications/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/medications/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/medications/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Observations

APIs for managing observations

Provide observations (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/observations" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/observations"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/observations',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/observations'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store an observation

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/observations" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"content\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/observations"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "content": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/observations',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'content' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/observations'
payload = {
    "content": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide an observation

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/observations/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/observations/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/observations/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/observations/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update an observation

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/observations/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"content\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/observations/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "content": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/observations/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'content' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/observations/9'
payload = {
    "content": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/observations/{id}

URL Parameters

id integer

The ID of the observation.

Body Parameters

content string

max.string.

clinic_id string optional

obrigatório_sem.

user_id string optional

obrigatório_sem.

Delete an observation

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/observations/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/observations/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/observations/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/observations/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Oximeter Records

APIs for managing oximeter records

Provide oximeter records between a given date(paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/oximeters" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"date_start\": \"2023-03-16T16:18:11\",
    \"date_end\": \"2023-03-16T16:18:11\"
}"

const url = new URL(
    "http://scan.test/api/oximeters"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:11",
    "date_end": "2023-03-16T16:18:11"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/oximeters',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'date_start' => '2023-03-16T16:18:11',
            'date_end' => '2023-03-16T16:18:11',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/oximeters'
payload = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:11",
    "date_end": "2023-03-16T16:18:11"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store an oximeter record

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/oximeters" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"oxygen\": 108148.6455,
    \"pr\": 108148.6455,
    \"pi\": 108148.6455,
    \"date\": \"2023-03-16T16:18:11\"
}"

const url = new URL(
    "http://scan.test/api/oximeters"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "oxygen": 108148.6455,
    "pr": 108148.6455,
    "pi": 108148.6455,
    "date": "2023-03-16T16:18:11"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/oximeters',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'oxygen' => 108148.6455,
            'pr' => 108148.6455,
            'pi' => 108148.6455,
            'date' => '2023-03-16T16:18:11',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/oximeters'
payload = {
    "user_id": 9,
    "oxygen": 108148.6455,
    "pr": 108148.6455,
    "pi": 108148.6455,
    "date": "2023-03-16T16:18:11"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide an oximeter record

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/oximeters/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/oximeters/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/oximeters/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/oximeters/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update an oximeter record

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/oximeters/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"oxygen\": 108148.6455,
    \"pr\": 108148.6455,
    \"pi\": 108148.6455,
    \"date\": \"2023-03-16T16:18:11\",
    \"user_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/oximeters/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "oxygen": 108148.6455,
    "pr": 108148.6455,
    "pi": 108148.6455,
    "date": "2023-03-16T16:18:11",
    "user_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/oximeters/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'oxygen' => 108148.6455,
            'pr' => 108148.6455,
            'pi' => 108148.6455,
            'date' => '2023-03-16T16:18:11',
            'user_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/oximeters/9'
payload = {
    "oxygen": 108148.6455,
    "pr": 108148.6455,
    "pi": 108148.6455,
    "date": "2023-03-16T16:18:11",
    "user_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/oximeters/{id}

URL Parameters

id integer

The ID of the oximeter.

Body Parameters

oxygen number

pr number

pi number

date string

encontro.

user_id string

Delete an oximeter record

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/oximeters/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/oximeters/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/oximeters/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/oximeters/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Pathologies

APIs for managing pathologies

Provide pathologies (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/pathologies" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/pathologies"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/pathologies',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/pathologies'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a pathology

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/pathologies" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"state\": false,
    \"pathologyType_id\": \"ducimus\",
    \"medical_base_record_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/pathologies"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "state": false,
    "pathologyType_id": "ducimus",
    "medical_base_record_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/pathologies',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'state' => false,
            'pathologyType_id' => 'ducimus',
            'medical_base_record_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/pathologies'
payload = {
    "state": false,
    "pathologyType_id": "ducimus",
    "medical_base_record_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a pathology

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/pathologies/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/pathologies/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/pathologies/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/pathologies/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a pathology

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/pathologies/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"state\": false,
    \"pathologyType_id\": \"ducimus\",
    \"medical_base_record_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/pathologies/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "state": false,
    "pathologyType_id": "ducimus",
    "medical_base_record_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/pathologies/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'state' => false,
            'pathologyType_id' => 'ducimus',
            'medical_base_record_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/pathologies/9'
payload = {
    "state": false,
    "pathologyType_id": "ducimus",
    "medical_base_record_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/pathologies/{id}

URL Parameters

id integer

The ID of the pathology.

Body Parameters

state boolean

pathologyType_id string

medical_base_record_id string

Delete a pathology

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/pathologies/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/pathologies/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/pathologies/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/pathologies/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Pathology Types

APIs for managing pathology types

Provide pathology types (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/pathology-types" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/pathology-types"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/pathology-types',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/pathology-types'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a pathology type

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/pathology-types" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"code\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\"
}"

const url = new URL(
    "http://scan.test/api/pathology-types"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/pathology-types',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'code' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/pathology-types'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a pathology type

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/pathology-types/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/pathology-types/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/pathology-types/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/pathology-types/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a pathology type

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/pathology-types/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"code\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\"
}"

const url = new URL(
    "http://scan.test/api/pathology-types/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/pathology-types/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'code' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/pathology-types/1'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete a pathology type

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/pathology-types/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/pathology-types/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/pathology-types/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/pathology-types/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Permissions

APIs for managing permissions

Update multiple permissions

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/permissions" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/permissions"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/permissions',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/permissions'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers)
response.json()

Received response:

Request failed with error:

Provide users permissions

requires authentication

Permissions are provided by role, without superadmin permissions

Example request:

curl --request GET \
    --get "http://scan.test/api/permissions" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/permissions"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/permissions',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/permissions'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store multiple permissions

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/permissions" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvy\",
    \"roles\": [
        \"ducimus\"
    ]
}"

const url = new URL(
    "http://scan.test/api/permissions"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvy",
    "roles": [
        "ducimus"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/permissions',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvy',
            'roles' => [
                'ducimus',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/permissions'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvy",
    "roles": [
        "ducimus"
    ]
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Prescriptions

APIs for managing prescriptions

Provide prescriptions (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/prescriptions" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/prescriptions"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/prescriptions',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/prescriptions'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a prescription

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/prescriptions" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"start_at\": \"2023-03-16T16:18:12\",
    \"end_at\": \"2023-03-16T16:18:12\",
    \"date_first_schedule\": \"2023-03-16T16:18:12\",
    \"dosage\": 0,
    \"dosage_unit\": \"ducimus\",
    \"frequency\": \"ducimus\",
    \"frequency_unit\": \"ducimus\",
    \"observation\": \"psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt\",
    \"user_id\": \"ducimus\",
    \"medication_id\": \"ducimus\",
    \"responsible_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/prescriptions"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "start_at": "2023-03-16T16:18:12",
    "end_at": "2023-03-16T16:18:12",
    "date_first_schedule": "2023-03-16T16:18:12",
    "dosage": 0,
    "dosage_unit": "ducimus",
    "frequency": "ducimus",
    "frequency_unit": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "user_id": "ducimus",
    "medication_id": "ducimus",
    "responsible_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/prescriptions',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'start_at' => '2023-03-16T16:18:12',
            'end_at' => '2023-03-16T16:18:12',
            'date_first_schedule' => '2023-03-16T16:18:12',
            'dosage' => 0,
            'dosage_unit' => 'ducimus',
            'frequency' => 'ducimus',
            'frequency_unit' => 'ducimus',
            'observation' => 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt',
            'user_id' => 'ducimus',
            'medication_id' => 'ducimus',
            'responsible_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/prescriptions'
payload = {
    "start_at": "2023-03-16T16:18:12",
    "end_at": "2023-03-16T16:18:12",
    "date_first_schedule": "2023-03-16T16:18:12",
    "dosage": 0,
    "dosage_unit": "ducimus",
    "frequency": "ducimus",
    "frequency_unit": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "user_id": "ducimus",
    "medication_id": "ducimus",
    "responsible_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/prescriptions

Body Parameters

start_at string

encontro.

end_at string

encontro.

date_first_schedule string

encontro.

dosage number

min.numérico.

dosage_unit string

(allowed) AMPOULE, APPLICATION, SPOON, PILL, CAPSULE, DRAGEIA, DROP, INHALATION, INJECTION, MILLILITER, NEBULIZATION, PASTILLE, PILULE, SEAL, SUPPOSITORY, OVULE, SACHET.

frequency string

frequency_unit string

(allowed) HOUR.

observation string optional

max.string.

user_id string

medication_id string

responsible_id string

User logged schedules.

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/prescriptions/user-prescriptions" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/prescriptions/user-prescriptions"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/prescriptions/user-prescriptions',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/prescriptions/user-prescriptions'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide a prescription

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/prescriptions/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/prescriptions/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/prescriptions/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/prescriptions/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Deactivate a prescription

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/prescriptions/cancel/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/prescriptions/cancel/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "PATCH",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/prescriptions/cancel/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/prescriptions/cancel/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers)
response.json()

Received response:

Request failed with error:

Update a prescription

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/prescriptions/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"start_at\": \"2023-03-16T16:18:12\",
    \"end_at\": \"2023-03-16T16:18:12\",
    \"date_first_schedule\": \"2023-03-16T16:18:12\",
    \"dosage\": 0,
    \"dosage_unit\": \"ducimus\",
    \"frequency\": \"ducimus\",
    \"frequency_unit\": \"ducimus\",
    \"observation\": \"psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt\",
    \"user_id\": \"ducimus\",
    \"medication_id\": \"ducimus\",
    \"responsible_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/prescriptions/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "start_at": "2023-03-16T16:18:12",
    "end_at": "2023-03-16T16:18:12",
    "date_first_schedule": "2023-03-16T16:18:12",
    "dosage": 0,
    "dosage_unit": "ducimus",
    "frequency": "ducimus",
    "frequency_unit": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "user_id": "ducimus",
    "medication_id": "ducimus",
    "responsible_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/prescriptions/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'start_at' => '2023-03-16T16:18:12',
            'end_at' => '2023-03-16T16:18:12',
            'date_first_schedule' => '2023-03-16T16:18:12',
            'dosage' => 0,
            'dosage_unit' => 'ducimus',
            'frequency' => 'ducimus',
            'frequency_unit' => 'ducimus',
            'observation' => 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt',
            'user_id' => 'ducimus',
            'medication_id' => 'ducimus',
            'responsible_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/prescriptions/9'
payload = {
    "start_at": "2023-03-16T16:18:12",
    "end_at": "2023-03-16T16:18:12",
    "date_first_schedule": "2023-03-16T16:18:12",
    "dosage": 0,
    "dosage_unit": "ducimus",
    "frequency": "ducimus",
    "frequency_unit": "ducimus",
    "observation": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "user_id": "ducimus",
    "medication_id": "ducimus",
    "responsible_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/prescriptions/{id}

URL Parameters

id integer

The ID of the prescription.

Body Parameters

start_at string

encontro.

end_at string

encontro.

date_first_schedule string

encontro.

dosage number

min.numérico.

dosage_unit string

(allowed) AMPOULE, APPLICATION, SPOON, PILL, CAPSULE, DRAGEIA, DROP, INHALATION, INJECTION, MILLILITER, NEBULIZATION, PASTILLE, PILULE, SEAL, SUPPOSITORY, OVULE, SACHET.

frequency string

frequency_unit string

(allowed) HOUR.

observation string optional

max.string.

user_id string

medication_id string

responsible_id string

Delete a prescription

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/prescriptions/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/prescriptions/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/prescriptions/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/prescriptions/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Professions

APIs for managing Professions

Provide jobs (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/professions" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/professions"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/professions',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/professions'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a job

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/professions" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/professions"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/professions',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/professions'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a job

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/professions/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/professions/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/professions/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/professions/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a job

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/professions/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/professions/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/professions/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/professions/9'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete a job

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/professions/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/professions/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/professions/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/professions/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Relationships

APIs for managing relationships

Provide relationships (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/relationships" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/relationships"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/relationships',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/relationships'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a relationship

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/relationships" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/relationships"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/relationships',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/relationships'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a relationship

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/relationships/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/relationships/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/relationships/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/relationships/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a relationship

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/relationships/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\"
}"

const url = new URL(
    "http://scan.test/api/relationships/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/relationships/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/relationships/9'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Destroy a relationship

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/relationships/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/relationships/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/relationships/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/relationships/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Relatives

APIs for managing relatives

Provide relatives (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/relatives" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/relatives"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/relatives',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/relatives'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a relative

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/relatives" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"email\": \"megane.corwin@example.org\",
    \"niss\": \"wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg\",
    \"phone\": \"qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw\",
    \"mobile_phone\": \"tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez\",
    \"qualifications\": \"efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt\",
    \"notes\": \"rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan\",
    \"relationship_id\": \"ducimus\",
    \"profession_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/relatives"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "email": "megane.corwin@example.org",
    "niss": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "phone": "qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw",
    "mobile_phone": "tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez",
    "qualifications": "efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt",
    "notes": "rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan",
    "relationship_id": "ducimus",
    "profession_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/relatives',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'email' => 'megane.corwin@example.org',
            'niss' => 'wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg',
            'phone' => 'qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw',
            'mobile_phone' => 'tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez',
            'qualifications' => 'efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt',
            'notes' => 'rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan',
            'relationship_id' => 'ducimus',
            'profession_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/relatives'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "email": "megane.corwin@example.org",
    "niss": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "phone": "qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw",
    "mobile_phone": "tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez",
    "qualifications": "efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt",
    "notes": "rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan",
    "relationship_id": "ducimus",
    "profession_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/relatives

Body Parameters

name string

max.string.

email string

o email.

niss string

max.string.

phone string

max.string.

mobile_phone string

max.string.

qualifications string

max.string.

notes string

max.string.

relationship_id string

profession_id string

Provide a relative

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/relatives/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/relatives/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/relatives/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/relatives/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a relative

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/relatives/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"email\": \"megane.corwin@example.org\",
    \"niss\": \"wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg\",
    \"phone\": \"qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw\",
    \"mobile_phone\": \"tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez\",
    \"qualifications\": \"efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt\",
    \"notes\": \"rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan\",
    \"user_id\": 9,
    \"relationship_id\": 9,
    \"profession_id\": 9
}"

const url = new URL(
    "http://scan.test/api/relatives/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "email": "megane.corwin@example.org",
    "niss": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "phone": "qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw",
    "mobile_phone": "tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez",
    "qualifications": "efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt",
    "notes": "rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan",
    "user_id": 9,
    "relationship_id": 9,
    "profession_id": 9
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/relatives/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'email' => 'megane.corwin@example.org',
            'niss' => 'wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg',
            'phone' => 'qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw',
            'mobile_phone' => 'tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez',
            'qualifications' => 'efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt',
            'notes' => 'rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan',
            'user_id' => 9,
            'relationship_id' => 9,
            'profession_id' => 9,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/relatives/9'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "email": "megane.corwin@example.org",
    "niss": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "phone": "qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw",
    "mobile_phone": "tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez",
    "qualifications": "efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt",
    "notes": "rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan",
    "user_id": 9,
    "relationship_id": 9,
    "profession_id": 9
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/relatives/{id}

URL Parameters

id integer

The ID of the relative.

Body Parameters

name string

max.string.

email string

o email.

niss string

max.string.

phone string

max.string.

mobile_phone string

max.string.

qualifications string

max.string.

notes string optional

max.string.

user_id integer

relationship_id integer

profession_id integer

Delete a relative

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/relatives/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/relatives/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/relatives/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/relatives/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Rgpds

APIs for managing rgpds

Store a password request

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/rgpds/verify" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"token\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/rgpds/verify"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "token": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/rgpds/verify',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'token' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/rgpds/verify'
payload = {
    "token": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Store a rgpd

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/rgpds" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "token=ducimus" \
    --form "file=@/tmp/phpIHTJEu"

const url = new URL(
    "http://scan.test/api/rgpds"
);

const headers = {
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('token', 'ducimus');
body.append('file', document.querySelector('input[name="file"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/rgpds',
    [
        'headers' => [
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'token',
                'contents' => 'ducimus'
            ],
            [
                'name' => 'file',
                'contents' => fopen('/tmp/phpIHTJEu', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/rgpds'
files = {
  'file': open('/tmp/phpIHTJEu', 'rb')
}
payload = {
    "token": "ducimus"
}
headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, files=files, data=payload)
response.json()

Received response:

Request failed with error:

Provide rgpds (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/rgpds" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/rgpds"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/rgpds',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/rgpds'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide a rgpd

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/rgpds/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/rgpds/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/rgpds/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/rgpds/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a rgpd

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/rgpds/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"doc_id\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"asked_for\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\",
    \"content\": \"ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn\",
    \"state\": false,
    \"user_id\": \"ducimus\",
    \"clinic_id\": \"ducimus\",
    \"responsible_id\": \"ducimus\",
    \"askType_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/rgpds/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "doc_id": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "asked_for": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "content": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "state": false,
    "user_id": "ducimus",
    "clinic_id": "ducimus",
    "responsible_id": "ducimus",
    "askType_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/rgpds/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'doc_id' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'asked_for' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
            'content' => 'ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn',
            'state' => false,
            'user_id' => 'ducimus',
            'clinic_id' => 'ducimus',
            'responsible_id' => 'ducimus',
            'askType_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/rgpds/9'
payload = {
    "doc_id": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "asked_for": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "content": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "state": false,
    "user_id": "ducimus",
    "clinic_id": "ducimus",
    "responsible_id": "ducimus",
    "askType_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/rgpds/{id}

URL Parameters

id integer

The ID of the rgpd.

Body Parameters

doc_id string

max.string.

asked_for string

max.string.

content string

max.string.

state boolean

user_id string

clinic_id string

responsible_id string

askType_id string

Delete a rgpd

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/rgpds/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/rgpds/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/rgpds/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/rgpds/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Roles

APIs for Roles

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/roles" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/roles"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/roles',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/roles'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/roles" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/roles"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/roles',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/roles'
payload = {
    "name": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

GET api/roles/list

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/roles/list" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/roles/list"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/roles/list',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/roles/list'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Display the specified resource.

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/roles/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/roles/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/roles/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/roles/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update the specified resource in storage.

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/roles/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"ducimus\",
    \"permissions\": [
        \"ducimus\"
    ]
}"

const url = new URL(
    "http://scan.test/api/roles/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "ducimus",
    "permissions": [
        "ducimus"
    ]
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/roles/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'ducimus',
            'permissions' => [
                'ducimus',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/roles/1'
payload = {
    "name": "ducimus",
    "permissions": [
        "ducimus"
    ]
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/roles/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/roles/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/roles/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/roles/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Schedules

APIs for managing schedules

Provide schedules (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/schedules" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/schedules"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/schedules',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/schedules'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a schedule

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/schedules" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"date\": \"2023-03-16T16:18:11\",
    \"status\": \"ducimus\",
    \"date_status\": \"2023-03-16T16:18:11\",
    \"prescription_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/schedules"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "date": "2023-03-16T16:18:11",
    "status": "ducimus",
    "date_status": "2023-03-16T16:18:11",
    "prescription_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/schedules',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'date' => '2023-03-16T16:18:11',
            'status' => 'ducimus',
            'date_status' => '2023-03-16T16:18:11',
            'prescription_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/schedules'
payload = {
    "date": "2023-03-16T16:18:11",
    "status": "ducimus",
    "date_status": "2023-03-16T16:18:11",
    "prescription_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Update a schedule

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/schedules/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"date\": \"2023-03-16T16:18:11\",
    \"status\": \"ducimus\",
    \"date_status\": \"2023-03-16T16:18:11\",
    \"prescription_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/schedules/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "date": "2023-03-16T16:18:11",
    "status": "ducimus",
    "date_status": "2023-03-16T16:18:11",
    "prescription_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/schedules/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'date' => '2023-03-16T16:18:11',
            'status' => 'ducimus',
            'date_status' => '2023-03-16T16:18:11',
            'prescription_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/schedules/9'
payload = {
    "date": "2023-03-16T16:18:11",
    "status": "ducimus",
    "date_status": "2023-03-16T16:18:11",
    "prescription_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/schedules/{id}

URL Parameters

id integer

The ID of the schedule.

Body Parameters

date string

encontro.

status string

date_status string optional

encontro.

prescription_id string

Delete a schedule

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/schedules/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/schedules/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/schedules/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/schedules/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

User logged schedules.

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/schedules/user-schedules" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"prescription_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/schedules/user-schedules"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "prescription_id": "ducimus"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/schedules/user-schedules',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'prescription_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/schedules/user-schedules'
payload = {
    "prescription_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

User logged schedules.

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/schedules/my-schedules" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"start\": \"2023-03-16 16:18:11\",
    \"end\": \"2023-03-16 16:18:11\"
}"

const url = new URL(
    "http://scan.test/api/schedules/my-schedules"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "start": "2023-03-16 16:18:11",
    "end": "2023-03-16 16:18:11"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/schedules/my-schedules',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'start' => '2023-03-16 16:18:11',
            'end' => '2023-03-16 16:18:11',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/schedules/my-schedules'
payload = {
    "start": "2023-03-16 16:18:11",
    "end": "2023-03-16 16:18:11"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide a schedule

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/schedules/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/schedules/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/schedules/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/schedules/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Set the status of a schedule

requires authentication

Example request:

curl --request PUT \
    "http://scan.test/api/schedules/9/set-status" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"status\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/schedules/9/set-status"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "status": "ducimus"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->put(
    'http://scan.test/api/schedules/9/set-status',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'status' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/schedules/9/set-status'
payload = {
    "status": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Sended Sms

APIs for managing sended sms

Provide multiple sms sended (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/sms-sended" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/sms-sended"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/sms-sended',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/sms-sended'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a sms sended

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/sms-sended" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"sent\": false,
    \"clinic_id\": \"ducimus\",
    \"smsTemplate_id\": \"ducimus\",
    \"user_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/sms-sended"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sent": false,
    "clinic_id": "ducimus",
    "smsTemplate_id": "ducimus",
    "user_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/sms-sended',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'sent' => false,
            'clinic_id' => 'ducimus',
            'smsTemplate_id' => 'ducimus',
            'user_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/sms-sended'
payload = {
    "sent": false,
    "clinic_id": "ducimus",
    "smsTemplate_id": "ducimus",
    "user_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a sms sended

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/sms-sended/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/sms-sended/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/sms-sended/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/sms-sended/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a sms sended

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/sms-sended/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"sent\": false,
    \"clinic_id\": \"ducimus\",
    \"smsTemplate_id\": \"ducimus\",
    \"user_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/sms-sended/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "sent": false,
    "clinic_id": "ducimus",
    "smsTemplate_id": "ducimus",
    "user_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/sms-sended/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'sent' => false,
            'clinic_id' => 'ducimus',
            'smsTemplate_id' => 'ducimus',
            'user_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/sms-sended/9'
payload = {
    "sent": false,
    "clinic_id": "ducimus",
    "smsTemplate_id": "ducimus",
    "user_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/sms-sended/{smssended}

URL Parameters

smssended integer

Body Parameters

sent boolean

clinic_id string

smsTemplate_id string

user_id string

Delete a sms sended

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/sms-sended/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/sms-sended/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/sms-sended/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/sms-sended/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Sms Templates

APIs for managing sms templates

Provide sms templates (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/sms-templates" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/sms-templates"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/sms-templates',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/sms-templates'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a sms template

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/sms-templates" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"subject\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"content\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\"
}"

const url = new URL(
    "http://scan.test/api/sms-templates"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "content": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/sms-templates',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'subject' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'content' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/sms-templates'
payload = {
    "subject": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "content": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a sms template

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/sms-templates/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/sms-templates/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/sms-templates/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/sms-templates/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a sms template

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/sms-templates/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"subject\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"content\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\"
}"

const url = new URL(
    "http://scan.test/api/sms-templates/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "subject": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "content": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/sms-templates/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'subject' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'content' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/sms-templates/9'
payload = {
    "subject": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "content": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete a sms template

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/sms-templates/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/sms-templates/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/sms-templates/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/sms-templates/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Smtp Configurations

APIs for managing smtp configurations

Provide smtp configurations (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/smtps" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/smtps"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/smtps',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/smtps'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a smtp configuration

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/smtps" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"hostname\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"port\": 108148.6455,
    \"mail_username\": \"pwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmm\",
    \"ssl\": \"gqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekki\",
    \"mail_password\": \"ducimus\",
    \"general_email\": \"psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt\",
    \"general_name\": \"pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe\",
    \"clinic_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/smtps"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "hostname": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "port": 108148.6455,
    "mail_username": "pwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmm",
    "ssl": "gqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekki",
    "mail_password": "ducimus",
    "general_email": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "general_name": "pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe",
    "clinic_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/smtps',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'hostname' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'port' => 108148.6455,
            'mail_username' => 'pwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmm',
            'ssl' => 'gqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekki',
            'mail_password' => 'ducimus',
            'general_email' => 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt',
            'general_name' => 'pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe',
            'clinic_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/smtps'
payload = {
    "hostname": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "port": 108148.6455,
    "mail_username": "pwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmm",
    "ssl": "gqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekki",
    "mail_password": "ducimus",
    "general_email": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "general_name": "pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe",
    "clinic_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/smtps

Body Parameters

hostname string

max.string.

port number

mail_username string

max.string.

ssl string

max.string.

mail_password string

general_email string

max.string.

general_name string

max.string.

clinic_id string

Provide a smtp configuration

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/smtps/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/smtps/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/smtps/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/smtps/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a smtp configuration

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/smtps/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"hostname\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"port\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\",
    \"mail_username\": \"ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn\",
    \"ssl\": \"yrfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfu\",
    \"general_email\": \"ythdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqd\",
    \"general_name\": \"wfaangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbm\",
    \"clinic_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/smtps/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "hostname": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "port": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "mail_username": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "ssl": "yrfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfu",
    "general_email": "ythdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqd",
    "general_name": "wfaangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbm",
    "clinic_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/smtps/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'hostname' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'port' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
            'mail_username' => 'ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn',
            'ssl' => 'yrfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfu',
            'general_email' => 'ythdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqd',
            'general_name' => 'wfaangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbm',
            'clinic_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/smtps/9'
payload = {
    "hostname": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "port": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "mail_username": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "ssl": "yrfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfu",
    "general_email": "ythdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqd",
    "general_name": "wfaangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbm",
    "clinic_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/smtps/{id}

URL Parameters

id integer

The ID of the smtp.

Body Parameters

hostname string

max.string.

port string

max.string.

mail_username string

max.string.

ssl string

max.string.

mail_password string optional

general_email string

max.string.

general_name string

max.string.

clinic_id string

Delete a smtp configuration

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/smtps/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/smtps/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/smtps/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/smtps/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Specialties

APIs for managing specialties

Provide specialties (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/specialties" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/specialties"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/specialties',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/specialties'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a specialty

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/specialties" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"code\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\"
}"

const url = new URL(
    "http://scan.test/api/specialties"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/specialties',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'code' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/specialties'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a specialty

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/specialties/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/specialties/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/specialties/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/specialties/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a specialty

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/specialties/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp\",
    \"code\": \"tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf\"
}"

const url = new URL(
    "http://scan.test/api/specialties/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/specialties/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp',
            'code' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/specialties/1'
payload = {
    "name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "code": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete a specialty

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/specialties/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/specialties/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/specialties/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/specialties/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Statistics

APIs for general graphic data

Provide information for a dashboard

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/statistics" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/statistics"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/statistics',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/statistics'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide information for a dashboard

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/statistics/patient" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/statistics/patient"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/statistics/patient',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/statistics/patient'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide information for a dashboard

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/statistics/collaborator" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/statistics/collaborator"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/statistics/collaborator',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/statistics/collaborator'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Thermometer Records

APIs for managing thermometer Records

Provide thermometer records (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/thermometers" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"date_start\": \"2023-03-16T16:18:12\",
    \"date_end\": \"2023-03-16T16:18:12\"
}"

const url = new URL(
    "http://scan.test/api/thermometers"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:12",
    "date_end": "2023-03-16T16:18:12"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/thermometers',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'date_start' => '2023-03-16T16:18:12',
            'date_end' => '2023-03-16T16:18:12',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/thermometers'
payload = {
    "user_id": 9,
    "date_start": "2023-03-16T16:18:12",
    "date_end": "2023-03-16T16:18:12"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a thermometer record

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/thermometers" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"temperature\": 108148.6455,
    \"date\": \"2023-03-16T16:18:12\"
}"

const url = new URL(
    "http://scan.test/api/thermometers"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "temperature": 108148.6455,
    "date": "2023-03-16T16:18:12"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/thermometers',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'temperature' => 108148.6455,
            'date' => '2023-03-16T16:18:12',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/thermometers'
payload = {
    "user_id": 9,
    "temperature": 108148.6455,
    "date": "2023-03-16T16:18:12"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Provide a thermometer record

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/thermometers/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/thermometers/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/thermometers/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/thermometers/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a thermometer record

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/thermometers/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"temperature\": 108148.6455,
    \"date\": \"2023-03-16T16:18:12\",
    \"user_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/thermometers/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "temperature": 108148.6455,
    "date": "2023-03-16T16:18:12",
    "user_id": "ducimus"
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/thermometers/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'temperature' => 108148.6455,
            'date' => '2023-03-16T16:18:12',
            'user_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/thermometers/9'
payload = {
    "temperature": 108148.6455,
    "date": "2023-03-16T16:18:12",
    "user_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Delete a thermometer record

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/thermometers/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/thermometers/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/thermometers/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/thermometers/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Users

APIs for managing users

Provide users (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/users" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/users"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/users',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a user

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/users" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "first_name=lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp" \
    --form "last_name=tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf" \
    --form "full_name=ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn" \
    --form "email=megane.corwin@example.org" \
    --form "username=wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg" \
    --form "email_verified_at=2023-03-16T16:18:10" \
    --form "password=ducimus" \
    --form "birthday=2023-03-16T16:18:10" \
    --form "remember_token=ducimus" \
    --form "country_id=ducimus" \
    --form "address=psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt" \
    --form "city=pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe" \
    --form "postcode=kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny" \
    --form "phone=rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy" \
    --form "mobilephone=thdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdw" \
    --form "tax_number=faangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmh" \
    --form "niss=iffhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahp" \
    --form "cc=vpnexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadh" \
    --form "gender=pyegkjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcv" \
    --form "language=gqsljixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuic" \
    --form "is_gdpr_accepted=1" \
    --form "gdpr_accepted_at=2023-03-16T16:18:10" \
    --form "gdpr_accepted_signature=psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt" \
    --form "photo=@/tmp/phpgXbo8Z"

const url = new URL(
    "http://scan.test/api/users"
);

const headers = {
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('first_name', 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp');
body.append('last_name', 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf');
body.append('full_name', 'ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn');
body.append('email', 'megane.corwin@example.org');
body.append('username', 'wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg');
body.append('email_verified_at', '2023-03-16T16:18:10');
body.append('password', 'ducimus');
body.append('birthday', '2023-03-16T16:18:10');
body.append('remember_token', 'ducimus');
body.append('country_id', 'ducimus');
body.append('address', 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt');
body.append('city', 'pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe');
body.append('postcode', 'kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny');
body.append('phone', 'rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy');
body.append('mobilephone', 'thdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdw');
body.append('tax_number', 'faangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmh');
body.append('niss', 'iffhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahp');
body.append('cc', 'vpnexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadh');
body.append('gender', 'pyegkjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcv');
body.append('language', 'gqsljixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuic');
body.append('is_gdpr_accepted', '1');
body.append('gdpr_accepted_at', '2023-03-16T16:18:10');
body.append('gdpr_accepted_signature', 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt');
body.append('photo', document.querySelector('input[name="photo"]').files[0]);

fetch(url, {
    method: "POST",
    headers,
    body,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/users',
    [
        'headers' => [
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'first_name',
                'contents' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp'
            ],
            [
                'name' => 'last_name',
                'contents' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf'
            ],
            [
                'name' => 'full_name',
                'contents' => 'ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn'
            ],
            [
                'name' => 'email',
                'contents' => 'megane.corwin@example.org'
            ],
            [
                'name' => 'username',
                'contents' => 'wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg'
            ],
            [
                'name' => 'email_verified_at',
                'contents' => '2023-03-16T16:18:10'
            ],
            [
                'name' => 'password',
                'contents' => 'ducimus'
            ],
            [
                'name' => 'birthday',
                'contents' => '2023-03-16T16:18:10'
            ],
            [
                'name' => 'remember_token',
                'contents' => 'ducimus'
            ],
            [
                'name' => 'country_id',
                'contents' => 'ducimus'
            ],
            [
                'name' => 'address',
                'contents' => 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt'
            ],
            [
                'name' => 'city',
                'contents' => 'pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe'
            ],
            [
                'name' => 'postcode',
                'contents' => 'kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny'
            ],
            [
                'name' => 'phone',
                'contents' => 'rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy'
            ],
            [
                'name' => 'mobilephone',
                'contents' => 'thdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdw'
            ],
            [
                'name' => 'tax_number',
                'contents' => 'faangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmh'
            ],
            [
                'name' => 'niss',
                'contents' => 'iffhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahp'
            ],
            [
                'name' => 'cc',
                'contents' => 'vpnexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadh'
            ],
            [
                'name' => 'gender',
                'contents' => 'pyegkjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcv'
            ],
            [
                'name' => 'language',
                'contents' => 'gqsljixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuic'
            ],
            [
                'name' => 'is_gdpr_accepted',
                'contents' => '1'
            ],
            [
                'name' => 'gdpr_accepted_at',
                'contents' => '2023-03-16T16:18:10'
            ],
            [
                'name' => 'gdpr_accepted_signature',
                'contents' => 'psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpgXbo8Z', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users'
files = {
  'photo': open('/tmp/phpgXbo8Z', 'rb')
}
payload = {
    "first_name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "last_name": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "full_name": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "email": "megane.corwin@example.org",
    "username": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "email_verified_at": "2023-03-16T16:18:10",
    "password": "ducimus",
    "birthday": "2023-03-16T16:18:10",
    "remember_token": "ducimus",
    "country_id": "ducimus",
    "address": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt",
    "city": "pmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfe",
    "postcode": "kkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnny",
    "phone": "rfezefmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuy",
    "mobilephone": "thdtrfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdw",
    "tax_number": "faangnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmh",
    "niss": "iffhaimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahp",
    "cc": "vpnexvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadh",
    "gender": "pyegkjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcv",
    "language": "gqsljixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuic",
    "is_gdpr_accepted": true,
    "gdpr_accepted_at": "2023-03-16T16:18:10",
    "gdpr_accepted_signature": "psdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajpt"
}
headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, files=files, data=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/users

Body Parameters

first_name string optional

max.string.

last_name string optional

max.string.

full_name string optional

max.string.

email string optional

o email.

username string

max.string.

email_verified_at string optional

encontro.

password string optional

birthday string optional

encontro.

remember_token string optional

country_id string

address string optional

max.string.

city string optional

max.string.

postcode string optional

max.string.

phone string optional

max.string.

mobilephone string optional

max.string.

tax_number string optional

max.string.

niss string optional

max.string.

cc string optional

max.string.

gender string optional

max.string.

language string optional

max.string.

photo file optional

Must be a file.

is_gdpr_accepted boolean optional

gdpr_accepted_at string optional

encontro.

gdpr_accepted_signature string optional

max.string.

clinic_default_id string optional

Provide users by role

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/users/my-collaborators" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/users/my-collaborators"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/users/my-collaborators',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/my-collaborators'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide users by role

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/users/my-collaborators-allow" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/users/my-collaborators-allow"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/users/my-collaborators-allow',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/my-collaborators-allow'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide collaborator associated patients (non-paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/users/my-patients" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/users/my-patients"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/users/my-patients',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/my-patients'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

POST api/users/update-role

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/users/update-role" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": 9,
    \"name\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/users/update-role"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": 9,
    "name": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/users/update-role',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 9,
            'name' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/update-role'
payload = {
    "user_id": 9,
    "name": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Associate a patient to a collaborator

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/users/associate-collaborator" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"user_id\": \"ducimus\",
    \"patient_id\": \"ducimus\"
}"

const url = new URL(
    "http://scan.test/api/users/associate-collaborator"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "user_id": "ducimus",
    "patient_id": "ducimus"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/users/associate-collaborator',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'user_id' => 'ducimus',
            'patient_id' => 'ducimus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/associate-collaborator'
payload = {
    "user_id": "ducimus",
    "patient_id": "ducimus"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

GET api/users/my-patients-paginated

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/users/my-patients-paginated" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/users/my-patients-paginated"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/users/my-patients-paginated',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/my-patients-paginated'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide users by role (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/users/by-role-paginated" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/users/by-role-paginated"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/users/by-role-paginated',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/by-role-paginated'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide collaborator associated patients (non-paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/users/get-possible-collabs/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/users/get-possible-collabs/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/users/get-possible-collabs/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/get-possible-collabs/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

GET api/users/roles/{user_id}

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/users/roles/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/users/roles/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/users/roles/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/roles/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide user observations (paginated)

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/users/observations/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/users/observations/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/users/observations/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/observations/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Provide a user

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/users/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/users/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/users/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update a user

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/users/1" \
    --header "Content-Type: multipart/form-data" \
    --header "Accept: application/json" \
    --form "first_name=lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp" \
    --form "last_name=tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf" \
    --form "full_name=ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn" \
    --form "email=megane.corwin@example.org" \
    --form "username=wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg" \
    --form "email_verified_at=2023-03-16T16:18:10" \
    --form "birthday=2023-03-16T16:18:10" \
    --form "address=qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw" \
    --form "city=tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez" \
    --form "postcode=efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt" \
    --form "mobilephone=rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan" \
    --form "tax_number=gnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmhiffh" \
    --form "niss=aimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahpvpne" \
    --form "cc=xvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadhpyeg" \
    --form "sns_number=kjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcvgqsl" \
    --form "gender=jixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuicdlqy" \
    --form "language=ewgueorcecquzlvcqvylqexlrtwhlegearvmxqlofgnocgnwdsddtngeioylhkpdimphjtxnljeerbigikqeevcriexwzghpfmoxitkfhargdatfpc" \
    --form "gdpr_accepted_signature=lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp" \
    --form "photo=@/tmp/phpAPKIvc"

const url = new URL(
    "http://scan.test/api/users/1"
);

const headers = {
    "Content-Type": "multipart/form-data",
    "Accept": "application/json",
};

const body = new FormData();
body.append('first_name', 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp');
body.append('last_name', 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf');
body.append('full_name', 'ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn');
body.append('email', 'megane.corwin@example.org');
body.append('username', 'wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg');
body.append('email_verified_at', '2023-03-16T16:18:10');
body.append('birthday', '2023-03-16T16:18:10');
body.append('address', 'qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw');
body.append('city', 'tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez');
body.append('postcode', 'efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt');
body.append('mobilephone', 'rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan');
body.append('tax_number', 'gnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmhiffh');
body.append('niss', 'aimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahpvpne');
body.append('cc', 'xvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadhpyeg');
body.append('sns_number', 'kjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcvgqsl');
body.append('gender', 'jixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuicdlqy');
body.append('language', 'ewgueorcecquzlvcqvylqexlrtwhlegearvmxqlofgnocgnwdsddtngeioylhkpdimphjtxnljeerbigikqeevcriexwzghpfmoxitkfhargdatfpc');
body.append('gdpr_accepted_signature', 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp');
body.append('photo', document.querySelector('input[name="photo"]').files[0]);

fetch(url, {
    method: "PATCH",
    headers,
    body,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/users/1',
    [
        'headers' => [
            'Content-Type' => 'multipart/form-data',
            'Accept' => 'application/json',
        ],
        'multipart' => [
            [
                'name' => 'first_name',
                'contents' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp'
            ],
            [
                'name' => 'last_name',
                'contents' => 'tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf'
            ],
            [
                'name' => 'full_name',
                'contents' => 'ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn'
            ],
            [
                'name' => 'email',
                'contents' => 'megane.corwin@example.org'
            ],
            [
                'name' => 'username',
                'contents' => 'wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg'
            ],
            [
                'name' => 'email_verified_at',
                'contents' => '2023-03-16T16:18:10'
            ],
            [
                'name' => 'birthday',
                'contents' => '2023-03-16T16:18:10'
            ],
            [
                'name' => 'address',
                'contents' => 'qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw'
            ],
            [
                'name' => 'city',
                'contents' => 'tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez'
            ],
            [
                'name' => 'postcode',
                'contents' => 'efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt'
            ],
            [
                'name' => 'mobilephone',
                'contents' => 'rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan'
            ],
            [
                'name' => 'tax_number',
                'contents' => 'gnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmhiffh'
            ],
            [
                'name' => 'niss',
                'contents' => 'aimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahpvpne'
            ],
            [
                'name' => 'cc',
                'contents' => 'xvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadhpyeg'
            ],
            [
                'name' => 'sns_number',
                'contents' => 'kjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcvgqsl'
            ],
            [
                'name' => 'gender',
                'contents' => 'jixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuicdlqy'
            ],
            [
                'name' => 'language',
                'contents' => 'ewgueorcecquzlvcqvylqexlrtwhlegearvmxqlofgnocgnwdsddtngeioylhkpdimphjtxnljeerbigikqeevcriexwzghpfmoxitkfhargdatfpc'
            ],
            [
                'name' => 'gdpr_accepted_signature',
                'contents' => 'lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp'
            ],
            [
                'name' => 'photo',
                'contents' => fopen('/tmp/phpAPKIvc', 'r')
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/1'
files = {
  'photo': open('/tmp/phpAPKIvc', 'rb')
}
payload = {
    "first_name": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp",
    "last_name": "tpmmgqerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsf",
    "full_name": "ekkiwtkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnn",
    "email": "megane.corwin@example.org",
    "username": "wowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajptpmmg",
    "email_verified_at": "2023-03-16T16:18:10",
    "birthday": "2023-03-16T16:18:10",
    "address": "qerxrirdffyjrvzcjvrxzadmmabpotayoszdjsndirwkxbfsolwgnnxxxocysizrvwqhvhgvppoavvqzwrohsghalgglppxlqfxyroowzsxsfekkiw",
    "city": "tkiwziksimnbfjpojpmanhsihsjjtowdcsxojpooajzqiofcwjclactenhocccjhnavdxwaenqvwfewekldkybasqopsbdjzzwfagqbstvrnnyrfez",
    "postcode": "efmfdqbykhpzuvmqylstzysprndptszilkufuefbotomafigxyblnswhajjvladbtrnlrnkxsamulictwzttwrcpjkiemqzdisofceiylinfuythdt",
    "mobilephone": "rfbmnzhfdosqqmfhepedgdrnswvshpmoevudenwjsyzggtcxuxtlhkyzfshtrxbaobareuzsspvbmnkzuwpiuzouwbmyhumqhwnsdefqgaaqdwfaan",
    "tax_number": "gnaqsqkdlesekmwuaxpdlzryuxpfjrkxspfuywiybhzzluhdwitexifglpabipjzegtpkynlfghusxruqfxxrrzhpobsuzjgxnrdrrngjqdbmhiffh",
    "niss": "aimhpytcvbeqmzfryaosjlwmykowjolbpvbveuvqxhszdroqifthkihamxnhnxhfibghfirwivwnwijpvesvvikcqpfkiibzgwtarbddljpahpvpne",
    "cc": "xvdywpvvbietmkefggaxcyogfmizuwcmfdtdgzqauyyeejsfjsqkxahbbaxijgpertqxzbxbesgiawgcxvdufgujvkgajnacdeqztgzqmfqadhpyeg",
    "sns_number": "kjjhxxwxrtrtfxulsscejgntoyycldasratsvupgbosypsrwlizwqwcqsxbfnbnzcetdsbyamgtbmxgzpuhogcxsgtqbrvscouqnyldjmkafcvgqsl",
    "gender": "jixpxrldhoxyxgqhsaoqnauewigckuvkqjgafruqdcyslisueztpvpzioulmbofeigdenrrwbbmaxfoeygkryxkjwqkkqtlwjgwbolwrixbuicdlqy",
    "language": "ewgueorcecquzlvcqvylqexlrtwhlegearvmxqlofgnocgnwdsddtngeioylhkpdimphjtxnljeerbigikqeevcriexwzghpfmoxitkfhargdatfpc",
    "gdpr_accepted_signature": "lpsdpwowlqjpohcbatpmuvnnokbvyixjzqebfwddanuulmfidhjkdmbgnckngvugouldarjdjuqkyxrljjocsxbarjieuqwgikjrlaoqaycjuqeajp"
}
headers = {
  'Content-Type': 'multipart/form-data',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, files=files, data=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/users/{user_id}

URL Parameters

user_id integer

The ID of the user.

Body Parameters

first_name string optional

max.string.

last_name string optional

max.string.

full_name string optional

max.string.

email string optional

o email.

username string

max.string.

email_verified_at string optional

encontro.

password string optional

birthday string optional

encontro.

address string optional

max.string.

city string optional

max.string.

postcode string optional

max.string.

mobilephone string optional

max.string.

tax_number string optional

max.string.

niss string optional

max.string.

cc string optional

max.string.

sns_number string optional

max.string.

gender string optional

max.string.

language string optional

max.string.

photo file optional

Must be a file.

gdpr_accepted_signature string optional

max.string.

Delete a user

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/users/1" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/users/1"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/users/1',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/users/1'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Warning Values

APIs for warning values

Display a listing of the resource.

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/warning-values" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/warning-values"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/warning-values',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/warning-values'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Store a newly created resource in storage.

requires authentication

Example request:

curl --request POST \
    "http://scan.test/api/warning-values" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"temp_min\": 108148.6455,
    \"oxy_min\": 108148.6455,
    \"pi_min\": 108148.6455,
    \"pr_min\": 108148.6455,
    \"qrs_min\": 108148.6455,
    \"qt_min\": 108148.6455,
    \"pvcs_min\": 108148.6455,
    \"hr_min\": 108148.6455,
    \"qtc_min\": 108148.6455,
    \"bs_min\": 108148.6455,
    \"sys_min\": 108148.6455,
    \"dia_min\": 108148.6455,
    \"dia_max\": 108148.6455,
    \"sys_max\": 108148.6455,
    \"temp_max\": 108148.6455,
    \"oxy_max\": 108148.6455,
    \"pi_max\": 108148.6455,
    \"pr_max\": 108148.6455,
    \"qrs_max\": 108148.6455,
    \"qt_max\": 108148.6455,
    \"pvcs_max\": 108148.6455,
    \"hr_max\": 108148.6455,
    \"qtc_max\": 108148.6455,
    \"bs_max\": 108148.6455,
    \"user_id\": 108148.6455
}"

const url = new URL(
    "http://scan.test/api/warning-values"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "temp_min": 108148.6455,
    "oxy_min": 108148.6455,
    "pi_min": 108148.6455,
    "pr_min": 108148.6455,
    "qrs_min": 108148.6455,
    "qt_min": 108148.6455,
    "pvcs_min": 108148.6455,
    "hr_min": 108148.6455,
    "qtc_min": 108148.6455,
    "bs_min": 108148.6455,
    "sys_min": 108148.6455,
    "dia_min": 108148.6455,
    "dia_max": 108148.6455,
    "sys_max": 108148.6455,
    "temp_max": 108148.6455,
    "oxy_max": 108148.6455,
    "pi_max": 108148.6455,
    "pr_max": 108148.6455,
    "qrs_max": 108148.6455,
    "qt_max": 108148.6455,
    "pvcs_max": 108148.6455,
    "hr_max": 108148.6455,
    "qtc_max": 108148.6455,
    "bs_max": 108148.6455,
    "user_id": 108148.6455
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->post(
    'http://scan.test/api/warning-values',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'temp_min' => 108148.6455,
            'oxy_min' => 108148.6455,
            'pi_min' => 108148.6455,
            'pr_min' => 108148.6455,
            'qrs_min' => 108148.6455,
            'qt_min' => 108148.6455,
            'pvcs_min' => 108148.6455,
            'hr_min' => 108148.6455,
            'qtc_min' => 108148.6455,
            'bs_min' => 108148.6455,
            'sys_min' => 108148.6455,
            'dia_min' => 108148.6455,
            'dia_max' => 108148.6455,
            'sys_max' => 108148.6455,
            'temp_max' => 108148.6455,
            'oxy_max' => 108148.6455,
            'pi_max' => 108148.6455,
            'pr_max' => 108148.6455,
            'qrs_max' => 108148.6455,
            'qt_max' => 108148.6455,
            'pvcs_max' => 108148.6455,
            'hr_max' => 108148.6455,
            'qtc_max' => 108148.6455,
            'bs_max' => 108148.6455,
            'user_id' => 108148.6455,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/warning-values'
payload = {
    "temp_min": 108148.6455,
    "oxy_min": 108148.6455,
    "pi_min": 108148.6455,
    "pr_min": 108148.6455,
    "qrs_min": 108148.6455,
    "qt_min": 108148.6455,
    "pvcs_min": 108148.6455,
    "hr_min": 108148.6455,
    "qtc_min": 108148.6455,
    "bs_min": 108148.6455,
    "sys_min": 108148.6455,
    "dia_min": 108148.6455,
    "dia_max": 108148.6455,
    "sys_max": 108148.6455,
    "temp_max": 108148.6455,
    "oxy_max": 108148.6455,
    "pi_max": 108148.6455,
    "pr_max": 108148.6455,
    "qrs_max": 108148.6455,
    "qt_max": 108148.6455,
    "pvcs_max": 108148.6455,
    "hr_max": 108148.6455,
    "qtc_max": 108148.6455,
    "bs_max": 108148.6455,
    "user_id": 108148.6455
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

POST api/warning-values

Body Parameters

temp_min number optional

oxy_min number optional

pi_min number optional

pr_min number optional

qrs_min number optional

qt_min number optional

pvcs_min number optional

hr_min number optional

qtc_min number optional

bs_min number optional

sys_min number optional

dia_min number optional

dia_max number optional

sys_max number optional

temp_max number optional

oxy_max number optional

pi_max number optional

pr_max number optional

qrs_max number optional

qt_max number optional

pvcs_max number optional

hr_max number optional

qtc_max number optional

bs_max number optional

user_id number

Display the specified resource.

requires authentication

Example request:

curl --request GET \
    --get "http://scan.test/api/warning-values/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/warning-values/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->get(
    'http://scan.test/api/warning-values/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/warning-values/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (401):

Show headers

cache-control: no-cache, private
content-type: application/json
vary: Origin


{
    "message": "Unauthenticated."
}

Received response:

Request failed with error:

Update the specified resource in storage.

requires authentication

Example request:

curl --request PATCH \
    "http://scan.test/api/warning-values/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"temp_min\": 108148.6455,
    \"oxy_min\": 108148.6455,
    \"pi_min\": 108148.6455,
    \"pr_min\": 108148.6455,
    \"qrs_min\": 108148.6455,
    \"qt_min\": 108148.6455,
    \"pvcs_min\": 108148.6455,
    \"hr_min\": 108148.6455,
    \"qtc_min\": 108148.6455,
    \"bs_min\": 108148.6455,
    \"sys_min\": 108148.6455,
    \"dia_min\": 108148.6455,
    \"dia_max\": 108148.6455,
    \"sys_max\": 108148.6455,
    \"temp_max\": 108148.6455,
    \"oxy_max\": 108148.6455,
    \"pi_max\": 108148.6455,
    \"pr_max\": 108148.6455,
    \"qrs_max\": 108148.6455,
    \"qt_max\": 108148.6455,
    \"pvcs_max\": 108148.6455,
    \"hr_max\": 108148.6455,
    \"qtc_max\": 108148.6455,
    \"bs_max\": 108148.6455,
    \"user_id\": 108148.6455
}"

const url = new URL(
    "http://scan.test/api/warning-values/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "temp_min": 108148.6455,
    "oxy_min": 108148.6455,
    "pi_min": 108148.6455,
    "pr_min": 108148.6455,
    "qrs_min": 108148.6455,
    "qt_min": 108148.6455,
    "pvcs_min": 108148.6455,
    "hr_min": 108148.6455,
    "qtc_min": 108148.6455,
    "bs_min": 108148.6455,
    "sys_min": 108148.6455,
    "dia_min": 108148.6455,
    "dia_max": 108148.6455,
    "sys_max": 108148.6455,
    "temp_max": 108148.6455,
    "oxy_max": 108148.6455,
    "pi_max": 108148.6455,
    "pr_max": 108148.6455,
    "qrs_max": 108148.6455,
    "qt_max": 108148.6455,
    "pvcs_max": 108148.6455,
    "hr_max": 108148.6455,
    "qtc_max": 108148.6455,
    "bs_max": 108148.6455,
    "user_id": 108148.6455
};

fetch(url, {
    method: "PATCH",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->patch(
    'http://scan.test/api/warning-values/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'temp_min' => 108148.6455,
            'oxy_min' => 108148.6455,
            'pi_min' => 108148.6455,
            'pr_min' => 108148.6455,
            'qrs_min' => 108148.6455,
            'qt_min' => 108148.6455,
            'pvcs_min' => 108148.6455,
            'hr_min' => 108148.6455,
            'qtc_min' => 108148.6455,
            'bs_min' => 108148.6455,
            'sys_min' => 108148.6455,
            'dia_min' => 108148.6455,
            'dia_max' => 108148.6455,
            'sys_max' => 108148.6455,
            'temp_max' => 108148.6455,
            'oxy_max' => 108148.6455,
            'pi_max' => 108148.6455,
            'pr_max' => 108148.6455,
            'qrs_max' => 108148.6455,
            'qt_max' => 108148.6455,
            'pvcs_max' => 108148.6455,
            'hr_max' => 108148.6455,
            'qtc_max' => 108148.6455,
            'bs_max' => 108148.6455,
            'user_id' => 108148.6455,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/warning-values/9'
payload = {
    "temp_min": 108148.6455,
    "oxy_min": 108148.6455,
    "pi_min": 108148.6455,
    "pr_min": 108148.6455,
    "qrs_min": 108148.6455,
    "qt_min": 108148.6455,
    "pvcs_min": 108148.6455,
    "hr_min": 108148.6455,
    "qtc_min": 108148.6455,
    "bs_min": 108148.6455,
    "sys_min": 108148.6455,
    "dia_min": 108148.6455,
    "dia_max": 108148.6455,
    "sys_max": 108148.6455,
    "temp_max": 108148.6455,
    "oxy_max": 108148.6455,
    "pi_max": 108148.6455,
    "pr_max": 108148.6455,
    "qrs_max": 108148.6455,
    "qt_max": 108148.6455,
    "pvcs_max": 108148.6455,
    "hr_max": 108148.6455,
    "qtc_max": 108148.6455,
    "bs_max": 108148.6455,
    "user_id": 108148.6455
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('PATCH', url, headers=headers, json=payload)
response.json()

Received response:

Request failed with error:

Request

PATCH api/warning-values/{warningValue_id}

URL Parameters

warningValue_id integer

The ID of the warningValue.

Body Parameters

temp_min number optional

oxy_min number optional

pi_min number optional

pr_min number optional

qrs_min number optional

qt_min number optional

pvcs_min number optional

hr_min number optional

qtc_min number optional

bs_min number optional

sys_min number optional

dia_min number optional

dia_max number optional

sys_max number optional

temp_max number optional

oxy_max number optional

pi_max number optional

pr_max number optional

qrs_max number optional

qt_max number optional

pvcs_max number optional

hr_max number optional

qtc_max number optional

bs_max number optional

user_id number

Remove the specified resource from storage.

requires authentication

Example request:

curl --request DELETE \
    "http://scan.test/api/warning-values/9" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://scan.test/api/warning-values/9"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'http://scan.test/api/warning-values/9',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://scan.test/api/warning-values/9'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Received response:

Request failed with error:

Introduction

Authenticating requests

AAuthentication

Login

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Body Parameters

Login into BackOffice

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Body Parameters

Get Api Token

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Body Parameters

Signup

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Body Parameters

Validate session

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Logout

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Validate session

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Validate session

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Aggregates

Provide aggregates (paginated)

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Store aggregates

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Body Parameters

Provide one aggregate

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Update one aggregate

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

Delete one aggregate

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Appointment

Provide appointments (paginated)

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Provide appointments

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Store an appointment

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Body Parameters

Provide one appointment

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Update one appointment

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

Delete one appointment

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Appointment Categories

Provide appointment categories (paginated)

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Provide appointment categories (paginated)

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Store an appointment category

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Body Parameters

Provide one appointment category

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Update one appointment category

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Body Parameters

Delete an appointment category

Request Try it out ⚡ Cancel 🛑 Send Request 💥

URL Parameters

Appointment Priorities

Provide appointment priorities (paginated)

Request Try it out ⚡ Cancel 🛑 Send Request 💥

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request

Request