Skip to content

Remote Waldur Api

Operations Summary

Method Endpoint Description
Core CRUD
POST /api/remote-waldur-api/pull_offering_details/{uuid}/ Details
POST /api/remote-waldur-api/pull_offering_invoices/{uuid}/ Invoices
POST /api/remote-waldur-api/pull_offering_orders/{uuid}/ Orders
POST /api/remote-waldur-api/pull_offering_resources/{uuid}/ Resources
POST /api/remote-waldur-api/pull_offering_robot_accounts/{uuid}/ Accounts
POST /api/remote-waldur-api/pull_offering_usage/{uuid}/ Usage
POST /api/remote-waldur-api/pull_offering_users/{uuid}/ Users
POST /api/remote-waldur-api/pull_order/{uuid} Schedule order pull task
POST /api/remote-waldur-api/pull_resource_robot_accounts/{uuid}/ Accounts
Other Actions
GET /api/remote-waldur-api/remote_resource_order_status/{resource_uuid}/ Get remote order details
GET /api/remote-waldur-api/remote_resource_status/{resource_uuid}/ Get remote resource sync status
GET /api/remote-waldur-api/remote_resource_team_status/{resource_uuid}/ Get remote resource team members
POST /api/remote-waldur-api/cancel_termination/{uuid} Cancel termination order
POST /api/remote-waldur-api/import_offering/ Create local offering from remote
POST /api/remote-waldur-api/push_project_data/{uuid}/ Data
POST /api/remote-waldur-api/remote_categories/ List remote marketplace categories
POST /api/remote-waldur-api/remote_customers/ List remote customers owned by current user
POST /api/remote-waldur-api/shared_offerings/ List remote importable offerings for particular customer
POST /api/remote-waldur-api/sync_resource/{uuid}/ Resource
POST /api/remote-waldur-api/sync_resource_project_permissions/{uuid}/ Permissions

Core CRUD

Details

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/pull_offering_details/string-value/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_pull_offering_details # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_pull_offering_details.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_pull_offering_details
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiPullOfferingDetails } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiPullOfferingDetails({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

Invoices

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/pull_offering_invoices/string-value/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_pull_offering_invoices # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_pull_offering_invoices.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_pull_offering_invoices
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiPullOfferingInvoices } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiPullOfferingInvoices({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

Orders

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/pull_offering_orders/string-value/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_pull_offering_orders # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_pull_offering_orders.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_pull_offering_orders
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiPullOfferingOrders } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiPullOfferingOrders({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

Resources

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/pull_offering_resources/string-value/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_pull_offering_resources # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_pull_offering_resources.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_pull_offering_resources
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiPullOfferingResources } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiPullOfferingResources({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

Accounts

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/pull_offering_robot_accounts/string-value/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_pull_offering_robot_accounts # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_pull_offering_robot_accounts.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_pull_offering_robot_accounts
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiPullOfferingRobotAccounts } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiPullOfferingRobotAccounts({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

Usage

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/pull_offering_usage/string-value/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_pull_offering_usage # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_pull_offering_usage.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_pull_offering_usage
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiPullOfferingUsage } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiPullOfferingUsage({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

Users

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/pull_offering_users/string-value/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_pull_offering_users # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_pull_offering_users.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_pull_offering_users
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiPullOfferingUsers } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiPullOfferingUsers({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

Schedule order pull task

Schedule order pull task

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/pull_order/string-value \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_pull_order # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_pull_order.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_pull_order
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiPullOrder } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiPullOrder({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

Accounts

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/pull_resource_robot_accounts/string-value/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_pull_resource_robot_accounts # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_pull_resource_robot_accounts.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_pull_resource_robot_accounts
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiPullResourceRobotAccounts } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiPullResourceRobotAccounts({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

Other Actions

Get remote order details

Get remote order details

1
2
3
4
http \
  GET \
  https://api.example.com/api/remote-waldur-api/remote_resource_order_status/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_remote_resource_order_status_retrieve # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_remote_resource_order_status_retrieve.sync(
    resource_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_remote_resource_order_status_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiRemoteResourceOrderStatusRetrieve } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiRemoteResourceOrderStatusRetrieve({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "resource_uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
resource_uuid string ✓

200 -

Field Type Description
order_uuid string (uuid) Order UUID
remote_state any Remote order state
local_state any Local order state
sync_status any Sync status: in_sync, out_of_sync, sync_failed

Get remote resource sync status

Get remote resource sync status

1
2
3
4
http \
  GET \
  https://api.example.com/api/remote-waldur-api/remote_resource_status/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_remote_resource_status_retrieve # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_remote_resource_status_retrieve.sync(
    resource_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_remote_resource_status_retrieve
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiRemoteResourceStatusRetrieve } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiRemoteResourceStatusRetrieve({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "resource_uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
resource_uuid string ✓

200 -

Field Type Description
local_state any Local resource state
remote_state any Remote resource state
sync_status any Sync status: in_sync, out_of_sync, sync_failed
last_sync string (date-time) Last sync timestamp

Get remote resource team members

Get remote resource team members

1
2
3
4
http \
  GET \
  https://api.example.com/api/remote-waldur-api/remote_resource_team_status/a1b2c3d4-e5f6-7890-abcd-ef1234567890/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_remote_resource_team_status_list # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_remote_resource_team_status_list.sync(
    resource_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    client=client
)

for item in response:
    print(item)
  1. API Source: remote_waldur_api_remote_resource_team_status_list
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiRemoteResourceTeamStatusList } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiRemoteResourceTeamStatusList({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "resource_uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
resource_uuid string ✓
Name Type Description
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.

200 -

The response body is an array of objects, where each object has the following structure:

Field Type Description
full_name string Full name
local_role string Local role
remote_role string Remote role
sync_status any Sync status: in_sync, out_of_sync, sync_failed

Cancel termination order

Cancel termination order

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/cancel_termination/string-value \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_cancel_termination # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_cancel_termination.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_cancel_termination
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiCancelTermination } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiCancelTermination({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

Create local offering from remote

Create local offering from remote

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
http \
  POST \
  https://api.example.com/api/remote-waldur-api/import_offering/ \
  Authorization:"Token YOUR_API_TOKEN" \
  api_url="https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  token="********" \
  remote_offering_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890" \
  local_category_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890" \
  local_customer_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890" \
  remote_customer_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.remote_offering_create_request import RemoteOfferingCreateRequest # (1)
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_import_offering # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = RemoteOfferingCreateRequest(
    api_url="https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    token="********",
    remote_offering_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    local_category_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    local_customer_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    remote_customer_uuid="a1b2c3d4-e5f6-7890-abcd-ef1234567890"
)
response = remote_waldur_api_import_offering.sync(
    client=client,
    body=body_data
)

print(response)
  1. Model Source: RemoteOfferingCreateRequest
  2. API Source: remote_waldur_api_import_offering
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
import { remoteWaldurApiImportOffering } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiImportOffering({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "api_url": "https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "token": "********",
    "remote_offering_uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "local_category_uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "local_customer_uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    "remote_customer_uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Field Type Required
api_url string (uri) ✓
token string ✓
remote_offering_uuid string (uuid) ✓
local_category_uuid string (uuid) ✓
local_customer_uuid string (uuid) ✓
remote_customer_uuid string (uuid) ✓

200 -

Field Type
uuid string (uuid)

Data

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/push_project_data/string-value/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_push_project_data # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_push_project_data.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_push_project_data
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiPushProjectData } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiPushProjectData({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

List remote marketplace categories

List remote marketplace categories

1
2
3
4
5
6
http \
  POST \
  https://api.example.com/api/remote-waldur-api/remote_categories/ \
  Authorization:"Token YOUR_API_TOKEN" \
  api_url="https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  token="********"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.remote_credentials_request import RemoteCredentialsRequest # (1)
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_remote_categories # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = RemoteCredentialsRequest(
    api_url="https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    token="********"
)
response = remote_waldur_api_remote_categories.sync(
    client=client,
    body=body_data
)

for item in response:
    print(item)
  1. Model Source: RemoteCredentialsRequest
  2. API Source: remote_waldur_api_remote_categories
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import { remoteWaldurApiRemoteCategories } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiRemoteCategories({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "api_url": "https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "token": "********"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
Field Type Required
api_url string (uri) ✓
token string ✓

200 -

The response body is an array of objects, where each object has the following structure:

Field Type Description
url string (uri)
uuid string (uuid)
title string
description string
icon string (uri)
default_vm_category boolean Set to "true" if this category is for OpenStack VM. Only one category can have "true" value.
default_volume_category boolean Set to true if this category is for OpenStack Volume. Only one category can have "true" value.
default_tenant_category boolean Set to true if this category is for OpenStack Tenant. Only one category can have "true" value.
offering_count integer
available_offerings_count integer
sections array of objects
sections.key string
sections.title string
sections.attributes array of objects
sections.attributes.key string
sections.attributes.title string
sections.attributes.type string
Enum: boolean, string, text, integer, choice, list
sections.attributes.options array of objects
sections.attributes.options.key string
sections.attributes.options.title string
sections.attributes.required boolean A value must be provided for the attribute.
sections.attributes.default any
sections.is_standalone boolean Whether section is rendered as a separate tab.
columns array of objects
columns.uuid string (uuid)
columns.index integer Index allows to reorder columns.
columns.title string Title is rendered as column header.
columns.attribute string Resource attribute is rendered as table cell.
columns.widget any Widget field allows to customise table cell rendering.
components array of objects
components.type string Unique internal name of the measured unit, for example floating_ip.
components.name string Display name for the measured unit, for example, Floating IP.
components.description string
components.measured_unit string Unit of measurement, for example, GB.
articles array of objects
articles.title string
articles.url string (uri)
group string (uri)

List remote customers owned by current user

List remote customers owned by current user

1
2
3
4
5
6
http \
  POST \
  https://api.example.com/api/remote-waldur-api/remote_customers/ \
  Authorization:"Token YOUR_API_TOKEN" \
  api_url="https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  token="********"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.remote_credentials_request import RemoteCredentialsRequest # (1)
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_remote_customers # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = RemoteCredentialsRequest(
    api_url="https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    token="********"
)
response = remote_waldur_api_remote_customers.sync(
    client=client,
    body=body_data
)

for item in response:
    print(item)
  1. Model Source: RemoteCredentialsRequest
  2. API Source: remote_waldur_api_remote_customers
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import { remoteWaldurApiRemoteCustomers } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiRemoteCustomers({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "api_url": "https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "token": "********"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
Field Type Required
api_url string (uri) ✓
token string ✓

200 -

The response body is an array of objects, where each object has the following structure:

Field Type
uuid string (uuid)
name string
abbreviation string
phone_number string
email string

List remote importable offerings for particular customer

List remote importable offerings for particular customer

1
2
3
4
5
6
http \
  POST \
  https://api.example.com/api/remote-waldur-api/shared_offerings/ \
  Authorization:"Token YOUR_API_TOKEN" \
  api_url="https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/" \
  token="********"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.models.remote_credentials_request import RemoteCredentialsRequest # (1)
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_shared_offerings # (2)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)

body_data = RemoteCredentialsRequest(
    api_url="https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    token="********"
)
response = remote_waldur_api_shared_offerings.sync(
    client=client,
    body=body_data
)

for item in response:
    print(item)
  1. Model Source: RemoteCredentialsRequest
  2. API Source: remote_waldur_api_shared_offerings
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import { remoteWaldurApiSharedOfferings } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiSharedOfferings({
  auth: "Token YOUR_API_TOKEN",
  body: {
    "api_url": "https://api.example.com/api/api-url/a1b2c3d4-e5f6-7890-abcd-ef1234567890/",
    "token": "********"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Description
customer_uuid string
page integer A page number within the paginated result set.
page_size integer Number of results to return per page.
Field Type Required
api_url string (uri) ✓
token string ✓

200 -

The response body is an array of objects, where each object has the following structure:

Field Type
uuid string (uuid)
name string
type string
state string
category_title string

Resource

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/sync_resource/string-value/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_sync_resource # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_sync_resource.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_sync_resource
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiSyncResource } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiSyncResource({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body

Permissions

1
2
3
4
http \
  POST \
  https://api.example.com/api/remote-waldur-api/sync_resource_project_permissions/string-value/ \
  Authorization:"Token YOUR_API_TOKEN"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from waldur_api_client.client import AuthenticatedClient
from waldur_api_client.api.remote_waldur_api import remote_waldur_api_sync_resource_project_permissions # (1)

client = AuthenticatedClient(
    base_url="https://api.example.com", token="YOUR_API_TOKEN"
)
response = remote_waldur_api_sync_resource_project_permissions.sync(
    uuid="string-value",
    client=client
)

print(response)
  1. API Source: remote_waldur_api_sync_resource_project_permissions
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import { remoteWaldurApiSyncResourceProjectPermissions } from 'waldur-js-client';

try {
  const response = await remoteWaldurApiSyncResourceProjectPermissions({
  auth: "Token YOUR_API_TOKEN",
  path: {
    "uuid": "string-value"
  }
});
  console.log('Success:', response);
} catch (error) {
  console.error('Error:', error);
}
Name Type Required
uuid string ✓

200 - No response body