Introduction

Welcome to the AssetWise DataStorage API!

The DataStorage REST API provides an intuitive programming interface to all AssetWise Information Management data entities, and this web site is the starting point for exploring the DataStorage REST programming interface to the AssetWise Information Management data entities. Its three-panel display contains entity tree, content and sample code panes.

Quick Links

Jump to Searching for Objects

Jump to Retrieving Objects

Jump to Swagger API Documentation

Navigating the Documentation

The recommended navigation of this web site is as follows. Users can make the best use of this documentation web site by adopting the following approach.

Choose Entity that Best Satisfies Current Requirement. The DataStorage Service REST API provides resources to manage many types of entities, including documents, tags, projects, people, organizations, and relationships between these types of objects. The first step in accessing the API is to determine the most appropriate entity to use.

Navigate or Search DataStorage Tree to Find Entity. Browse the identity tree or use the search field to find the chosen entity. Most of the commonly used entities, including documents, tags, projects, people, organizations, are available in the Business Entities section of the entity tree.

Click Entity to Display its Documentation in the Content Pane. Clicking on the chosen entity displays information about the entity in the content pane, including the available parameters and associated default values. Add any of the available parameters to an HTTP header and set values as required to send information to the DataStorage Service.

Choose Action to Perform on the Entity. The DataStorage Service REST API uses HTTP methods to access or update entities. Use the GET method to search for entities matching criteria specified in the HTTP header. The PATCH and POST methods allow additions or updates to server entities. The sample code pane illustrates correct calling comventions for the HTTP request methods.

Choose Parameter Values for Selected Action. Specify entities to search for through parameters in the request header. Most GET methods create EQL queries to return result sets. Adding a context to the HTTP header restricts searching to a specific AssetWise community. Similarly, adding an "id" to the HTTP header retrieves the entity specified by the "id" and its associated metadata.

Test API Call in Swagger. Use the "Try me in Swagger" link to test the operation of the API. The Swagger page "Try it out" function sends parameters to the DataStorage Service in the HTTP header. Users may find it helpful to have the documentation page open in a separate browser window while they are

Review Results. The Swagger "Try it out" feature causes the API to process the HTTP request, and returns the results on the Swagger page.

Using the API

Users access the API by invoking an HTTP request method, most commonly GET or POST, to act on a resource. HTTP requests to the DataStorage Service access resources, while their headers pass additional information to and from the server.

RESTful resources are pluralized nouns, e.g., Persons. There are usually many instances of each type of resource, and users can access a specific resource by providing its unique identifier, such as Persons/{id}. Resources are held in a data source or 'context' that comprises part of a URL, e.g., {context}/Persons/{id}.

The prefix api isolates APIs from other application resources, e.g., api/{context}/Persons/{id}. The prefix can also distinguish between different versions of the API, as in api-v2/{context}/Persons/{id}. The full URL includes the protocol, server and port according to the following pattern.

{protocol}://{server}[:{port}]/api[-{version}[/{context}]/{Resource}[/{id}]

# A single Person in a specific community
https://datastorage.bentley.com/api/3422FC0E-136C-4532-9D8B-F8B2CE28A94C/Persons/123

# A collection of Persons in a specific community
https://datastorage.bentley.com/api/3422FC0E-136C-4532-9D8B-F8B2CE28A94C/Persons

# A collection of all Open Sessions of the user for all available communities
https://session.bentley.com/api/Sessions

# The same call as above but targeting a specific version of the API
https://session.bentley.com/api-v1/SomeOldEntity

The following figure illustrates a complete GET and POST requests to an HTTP server, including authentication.

Query Parameters

Use a GET method when the query parameters produce a URL that is shorter than 2000 characters.

$ curl -X GET "https://datastorage.dev.aw-au.bentley.com/api/0/Documents?filter=Name+LIKE+%27A%25%27"

If the query parameters would produce a URL that is longer than 2000 characters, use a POST method with the query parameters in the request body.

curl -X POST "https://datastorage.dev.aw-au.bentley.com/api/0/Search" /
-H "Content-Type: text/plain" /
-d "START WITH Document SELECT Id, Code WHERE Name LIKE 'A%'"

Authentication

# Login to Session service (at https://session.dev.aw-au.bentley.com)
#    Once logged in you can yet your sessionToken from : https://session.dev.aw-au.bentley.com/Session/Token?authority=https%3A%2F%2Fqa-imsoidc.bentley.com&label=session
$sessionToken = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6IjQ3OTQ4QjgzNTY2RDk1MDAxODRDQjRC ..."

#    Then use the SessionToken to get the desired [IMS] AccessToken
$headers = @{
    "Authorization" = "Bearer $sessionToken"
}

# Call the DataStorage
$result = Invoke-WebRequest -Uri "https://datastorage.dev.aw-au.bentley.com/api/0/Documents?pageSize=20" -Method GET -Headers $headers 

# Display the results
$result.Content

Make sure to replace sessionToken with your API key.

Authenticating client connections to the HTTP server requires three steps.

1. Call the IMS Authority Service to obtain an IMS access token.

2. Pass the IMS access token to the Session Service to obtain a session bearer token.

3. Parameterize the session bearer token into a DataStorage Service HTTP request header.

DataStorage expects the SessionTokens to be included in all API requests to the server in a header that looks like the following:

Authorization: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6IjQ3OTQ4QjgzNTY2RDk1MDAxODRDQjRC ...

Context

A context (community) is a collection of AssetWise data, users, groups and permissions. A context may exist in one database or be distributed across several servers. Users may not simultaneously access information from multiple communities.

Searching

All business entities provide a GET request method to search for entities matching user-supplied filter criteria with the following syntax. /api/{Context}/{EntityNameInPlural}?include=Id,Code,Class.Id&filter=Code LIKE '*LN9*'&startAt=1&pageSize=30&order=Class.Id

The result of a search operation is a flat list of the properties selected in the include parameter. This list may contain properties from any level of the object hierarchy.

Users must specify a context (community) to narrow the search. Setting the value of the context parameter to "0" references the current context.

Before invoking the method, set up the HTTP request header to pass the following parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the following parameters to control how results are returned.

   Parameter	Description
   include	Properties to return in result set. (Defaults to "Id", "Name", "Code" and "Class.Id" depending on the Entity)
   filter	Search criteria. (Defaults to "Id>1".)
   order	Ordering of the search results.
   startAt	Index of the first row returned. (Defaults to 1.)
   pageSize	Maximum number of rows returned. (User specific setting.)

The result set contains a list of properties for entities satisfying the search criteria. The result set should include the "id" parameter to allow further entity operations, such as retrieving more detailed information related to an entity of interest.

Return to Introduction

Retrieving

The GET request method can retrieve more detailed information for a specific entity identified by "id", and the syntax for this form of the GET request is as follows.

/api/{Context}/{EntityNameInPlural}/{id}?include=Header;Attributes

The Retrieve operation returns the object hierarchy based on the Retrieve Options applied in the include parameter. Every retrievable entity supports the "Header" option which typically populate the primary properties of the object (e.g. Name, Code etc). Options can be combined in a single request using the ; as a separator. Options may also be specialized with filters. For more information on the available options and their filters per entity please check the related entity section.

Users must provide the "id" for an entity of interest, and a context (community). Setting the value of the context parameter to "0" references the current context.

Before invoking the method, set up the HTTP request header to pass the following parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the following parameters to control how results are returned.

   Parameter	Description
   include	Entity specific Retrieve options (Defaults to "Header").

The result set can include a more detailed set of properties for the entity specified by "id". Setting the value of the "include" parameter to "Header" returns a predefined set of properties.

Return to Introduction

Transaction

Every operation that affects the state of an entity is executed in its own transaction (except when Bulk Transactions are used). When an error occurs the transaction is rolled back and no changes are applied.

Add, Change, Delete

The caller doesn't need to take any special action for executing the operation using a transaction. User's ability to Add, Change or Delete an entity is controlled by his/her permissions and roles which are configured by the system administrator.

Paging

Due to the extended size of Business Entities all GET operations support Paging, typically controlled with parameters like startAt and pageSize. The latter is constraint by a system setting (MaxRowsToReturn).

When no pageSize is defined, the system will return at most MaxRowsToReturn records and the caller needs to repeat the request by setting the startAt parameter to the appropriate value (e.g. startAt += pageSize). e.g. /api/{Context}/{EntityNameInPlural}?include=Id,Code,Class.Id&filter=Code LIKE '*LN9*'&startAt=1&pageSize=30&order=Class.Id and then repeat /api/{Context}/{EntityNameInPlural}?include=Id,Code,Class.Id&filter=Code LIKE '*LN9*'&startAt=31&pageSize=30&order=Class.Id

The same logic applies for retrieve options that support the related filters. /api/{Context}/{Entity}/{id}?include=Header;Attributes[startAt=1, pageSize=30] and repeat with /api/{Context}/{Entity}/{id}?include=Header;Attributes[startAt=31, pageSize=30]

Bulk Transactions

Not available yet.

Errors

When a request cannot be handled by the system, the response status code is 4xx or 5xx (depending on the case) and an error description is available in the response body.

When the error is something that requires the user's attention, then the status code is in the 4xx range. When the error is unexpected the response is 500 and the user is advised to log a defect with the request and response data.

GET

The GET method is used to retrieve a resource or collection of resources. GET should only retrieve data and should have no other effect on the data.

Typical return codes differ between getting a known resource vs searching across possible resources. When you access a known resource the possible Error codes may be

When searching across possible resources the possible Error codes may be:

POST

Use POST to create or add a new resource. The result of a POST is typically a new identifier which can later be used as part of the resource identifier

Possible Error codes are:

PUT

Use PUT to replace a resource in its entirety. Complex resources will typically not be replaced but rather just changed partially. For those cases use PATCH instead. Because PUT [re]places the entire resource it can also be used in cases where the unique identifiers is known by the caller. I.e. as an add or replace.

Possible Error codes are:

PATCH

Use PATCH for partial updates to a resource. This is most commonly associated with change. With PATCH you typically only send the data you want to change. Also use PATCH when sending batch updates to the server. I.e. updates that affect more than one resource.

Possible Error codes are:

DELETE

Removes the resource or collection of resources.

Possible Error codes are:

Common Objects

Objects

Supported operations

Searching [GET] /api/{Context}/Objects

Retrieving [GET] /api/{Context}/Objects/{id}

Create From Template [POST] /api/{Context}/Templates/{id}/Instances

An Object is an 'Independent Object' and a key entity in the system.

An Object can be classified using Class and support Templates.

The read-only Id property is the unique identifier. This identifier is assigned on creation and used in subsequent actions like Retrieve .

An Object supports Namespace identification.

The ObjectType identifier for Object is 231.

The Object does not support Instance Permission (i.e. Permission to View/Add/Change/Delete are granted accross all records of this Type).

You can use Object as the root [START WITH] type in a Search . A number of properties including: Id, Type, Label, Keywords, Notes, Responsibilities etc. are available to the search. To find a full list of searchable properties use SearchableTypes .

Searching Objects

$ curl https://datastorage.dev.aw-au.bentley.com//api/{Context}/Objects/?include=Id,Name,Code,Class.Id&filter=Id=1&startAt=0&pageSize=20
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function searchObjects( host, include= 'Id,Name,Code,Class.Id', filter, order, startAt = 0, pageSize = 10) {
   let requestUrl = host + '/api/0/Objects?include=' + include +'&filter=' + filter +;&order=' + order +'&startAt=' + startAt + '&pageSize=' + pageSize;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

[
{
  "classId": 998,
  "code": "sample",
  "id": 998,
  "name": "sample"
},
{
  "classId": 999,
  "code": "sample",
  "id": 999,
  "name": "sample"
}
]

Enables Searching on Objects using the EQL logic.

Use the GET request method to search for Objects that satisfy a set of search criteria.

GET /api/{Context}/Objects

Specify a context (community) to indicate the data source. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the parameters in the table below to control how the result set displays the returned properties.

The result set contains the selected list of properties for Objects satisfying the provided search criteria. The result set should include the "id" parameter to allow further operations, such as retrieving detailed information related to a Object of interest.

Try me in EqlExplorer
Try me in Swagger

Search Object Request Info

Search Object Request Parameters

Search Object Responses

Retrieving Objects

$ curl https://datastorage.dev.aw-au.bentley.com/{Context}/Objects/242?include={RetrieveOptions}
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function retrieveObjects( host, id, retrieveOptions = 'Header') {
   let requestUrl = host + '/api/0/Objects/id/?include=' + retrieveOptions;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Retrieves a single Object instance the properties of which are populated based on the request parameters.

This GET request method can retrieve more detailed information for the Object identified by its "id". The syntax for this form of the GET request is as follows.

GET /api/{Context}/Objects/{id}

Use the "id" for the Object to retrieve, and specify a context (community) to narrow the search. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the "include" parameter to specify the properties returned in the result set. (Defaults to "Header").

The GET method returns the properties specified in the HTTP request header for the document copy identified by "id".

Try me in RetrieveExplorer
Try me in Swagger

Search Object Request Info

Retrieve Object Request Parameters

Retrieve Object Properties per include option.

RetrieveObject Responses

Templates

Supported operations

Searching [GET] /api/{Context}/Templates

Retrieving [GET] /api/{Context}/Templates/{id}

Creating [POST] /api/{Context}/Templates

Changing [PATCH] /api/{Context}/Templates/{id}

Deleting [DELETE] /api/{Context}/Templates/{id}

Creating Business Objects [POST] /api/{Context}/Templates/{id}/Instances

A Template is an 'Independent Object'.

A Template may be created in any Scope .

The read-only Id property is the unique identifier. This identifier is assigned on creation and used in subsequent actions like Retrieve .

A Template supports Namespace identification.

A Template is unique across ( name, object_type, namespace_id ).

The ObjectType identifier for Template is 188.

The Template supports the instance permissions: View, Modify, Approve, CanUse and Delete in addition to the Type permission that governs its creation.

You can use Template as the root [START WITH] type in a Search . A number of properties including: Id, Scope, Namespace, Name, Description, AuditDetails etc. are available to the search. To find a full list of searchable properties use SearchableTypes .

Templates let users easily create objects. When a user instantiates an entity, the system copies the relevant template so that the resulting object inherits default attribute values, relationships and security definition from the template. Each AssetWise entity may have multiple templates with differing properties, relationships and security. All templates associated with an entity class inherit all of the attributes associated with the class. However, each template associated with the class can assign different default values to the objects created from the template.

Creating Business Objects

Request Body (JSON)

{
  "mask": "string value",
  "options": "string value",
  "attributes": null
}

$ curl -X POST https://datastorage.dev.aw-au.bentley.com/{Context}/Templates/{id}/Instances
-H "Accept: application/json"
-H "Authorization: Bearer {token}"
-d "see json request body"

// the modelPost structure is described in the Request Json 
async function createFromTemplate( host, templateId, templateInstancePost) {{
   let requestUrl = host + '/api/0/Templates/'+templateId+'/Instances'
   const init = {
      method: 'POST',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = templateInstancePost.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

{
  "id": 999
}

Creating business objects can be achieved by making use of the following methods.

• By calling related api POST api/{context}/{EntityNameInPlural} which is described in detail for each business object.

• By Copying an existing business object using POST api/{context}/{EntityNameInPlural}/{id}/InstanceCopies which is described in detail for each business object.

• Using a Template, which is described in the following paragraphs.

Templates are special system objects which allow the creation of new Business Entities using a parametrized entity -the model.

Post Creating Business Objects Request Info

Post Creating Business Objects Info

The Creating Business Objects POST request accepts the TemplateInstancePost contract, with the following properties

Searching Templates

$ curl https://datastorage.dev.aw-au.bentley.com//api/{Context}/Templates/?include=Id,Name,Class.Id&filter=Id=1&startAt=0&pageSize=20
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function searchTemplates( host, include= 'Id,Name,Class.Id', filter, order, startAt = 0, pageSize = 10) {
   let requestUrl = host + '/api/0/Templates?include=' + include +'&filter=' + filter +;&order=' + order +'&startAt=' + startAt + '&pageSize=' + pageSize;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

[
{
  "classId": 998,
  "id": 998,
  "name": "sample"
},
{
  "classId": 999,
  "id": 999,
  "name": "sample"
}
]

Enables Searching on Templates using the EQL logic.

Use the GET request method to search for Templates that satisfy a set of search criteria.

GET /api/{Context}/Templates

Specify a context (community) to indicate the data source. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the parameters in the table below to control how the result set displays the returned properties.

The result set contains the selected list of properties for Templates satisfying the provided search criteria. The result set should include the "id" parameter to allow further operations, such as retrieving detailed information related to a Template of interest.

Try me in EqlExplorer
Try me in Swagger

Search Template Request Info

Search Template Request Parameters

Search Template Responses

Retrieving Templates

$ curl https://datastorage.dev.aw-au.bentley.com/{Context}/Templates/242?include={RetrieveOptions}
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function retrieveTemplates( host, id, retrieveOptions = 'Header') {
   let requestUrl = host + '/api/0/Templates/id/?include=' + retrieveOptions;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

/* Sample request for Template */
{
  "name": "sample",
  "description": "sample",
  "codeMask": "sample",
  "class": {
    "code": "sample",
    "name": "sample",
    "sysType": "sample",
    "isSyncTracked": false,
    "path": "sample",
    "id": 999
  },
  "model": {
    "type": 999,
    "label": "sample",
    "id": 999
  },
  "identGenFlag": 999,
  "isPrototype": true,
  "codeMaskExpression": "sample",
  "usageFlags": 999,
  "status": "sample",
  "scope": {
    "name": "sample",
    "id": 999
  },
  "namespace": {
    "name": "sample",
    "id": 999
  },
  "hasFlags": 9999,
  "permissionHint": 999,
  "dateAdded": "2020-09-10T12:09:03.311347+01:00",
  "addedBy": {
    "id": 999
  },
  "dateChanged": "2020-09-10T12:09:03.311518+01:00",
  "changedBy": {
    "id": 999
  },
  "revisionRule": {
    "id": 999,
    "forceOrder": false,
    "forceValue": false
  },
  "snapshotDef": {
    "autoOnly": true,
    "cardinality": 999,
    "contentRetrieveOptions": "sample",
    "derivedFrom": {
      "id": 999
    },
    "id": 999,
    "mayIgnoreEvent": true,
    "renditionType": 999,
    "targetType": 999
  },
  "id": 999
}

Retrieves a single Template instance the properties of which are populated based on the request parameters.

This GET request method can retrieve more detailed information for the Template identified by its "id". The syntax for this form of the GET request is as follows.

GET /api/{Context}/Templates/{id}

Use the "id" for the Template to retrieve, and specify a context (community) to narrow the search. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the "include" parameter to specify the properties returned in the result set. (Defaults to "Header").

The GET method returns the properties specified in the HTTP request header for the document copy identified by "id".

Try me in RetrieveExplorer
Try me in Swagger

Search Template Request Info

Retrieve Template Request Parameters

Retrieve Template Properties per include option.

RetrieveTemplate Responses

Creating Templates

Try me in Swagger

Request Body (JSON)

{
  "name": "string value",
  "description": "string value",
  "codeMask": "string value",
  "class": {
    "id": 999
  },
  "model": {
    "type": 999,
    "id": 999
  },
  "identGenFlag": 999,
  "isPrototype": true,
  "codeMaskExpression": "string value",
  "usageFlags": 999
}

$ curl -X POST https://datastorage.dev.aw-au.bentley.com/{Context}/Templates
-H "Accept: application/json"
-H "Authorization: Bearer {token}"
-d "see json request body"

// the modelPost structure is described in the Request Json 
async function postTemplates( host, modelPost) {
   let requestUrl = host + '/api/0/Templates
   const init = {
      method: 'POST',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = modelPost.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

{
  "id": 999
}

The following methods are available for creating a new instance of Template.

1. Calling the API directly providing the required data.

2. Using a Template

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server. Set the "Authorization" parameter to a valid session bearer token.

Add Template Request Info

Post Template Contract Info

The POST request for Template contract has the following properties

Add Template Response Statuses

Changing Templates

Try me in Swagger

Request Body (JSON)

{
  "name": "string value",
  "description": "string value",
  "codeMask": "string value",
  "class": {
    "id": 999
  },
  "status": "string value",
  "model": {
    "id": 999
  },
  "identGenFlag": 999,
  "isPrototype": true,
  "codeMaskExpression": "string value",
  "usageFlags": 999,
  "id": 999
}

$ curl -X PATCH https://datastorage.dev.aw-au.bentley.com/{Context}/Templates
-H "Accept: application/json"
-H "Authorization: Bearer {token}"
-d "see json request"

// the modelPatch structure is described in the Request Json 
async function patchTemplates( host, id, modelPatch) {
   let requestUrl = host + '/api/0/Templates/'+id
   const init = {
      method: 'PATCH',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = modelPatch.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Saves the modification on the Template instance to the database.

Try me in Swagger

Change Template Request Info

Patch Template Contract Info

The Template properties for a PATCH requests are:

Patch Template Responses

Deleting Templates

Try me in Swagger

$ curl -X DELETE https://datastorage.dev.aw-au.bentley.com/{Context}/Templates/123
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function DeleteTemplates( host, id) {
   let requestUrl = host + '/api/0/Templates/+id+
   const init = {
      method: 'DELETE',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = model.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Deletes the Template instance from the database.

Delete Template Request Info

Delete Template Responses

Keywords

Supported operations

Searching [GET] /api/{Context}/Keywords

Retrieving [GET] /api/{Context}/Keywords/{id}

Creating [POST] /api/{Context}/Keywords

Changing [PATCH] /api/{Context}/Keywords/{id}

Deleting [DELETE] /api/{Context}/Keywords/{id}

A Keyword is classified as a 'Data Domain Definition' which mean that it purpose is to define the type and value of an attribute rather than being a significant object in itself.

A Keyword may be created in any Scope .

The read-only Id property is the unique identifier. This identifier is assigned on creation and used in subsequent actions like Retrieve .

A Keyword supports Namespace identification.

A Keyword is unique across ( keyword, namespace_id ).

The ObjectType identifier for Keyword is 66.

The Keyword does not support Instance Permission (i.e. Permission to View/Add/Change/Delete are granted accross all records of this Type).

You can use Keyword as the root [START WITH] type in a Search . A number of properties including: Id, Scope, Namespace, Name, Objects, KeywordGroups etc. are available to the search. To find a full list of searchable properties use SearchableTypes .

Searching Keywords

$ curl https://datastorage.dev.aw-au.bentley.com//api/{Context}/Keywords/?include=Id,Name&filter=Id=1&startAt=0&pageSize=20
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function searchKeywords( host, include= 'Id,Name', filter, order, startAt = 0, pageSize = 10) {
   let requestUrl = host + '/api/0/Keywords?include=' + include +'&filter=' + filter +;&order=' + order +'&startAt=' + startAt + '&pageSize=' + pageSize;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

[
{
  "id": 998,
  "name": "sample"
},
{
  "id": 999,
  "name": "sample"
}
]

Enables Searching on Keywords using the EQL logic.

Use the GET request method to search for Keywords that satisfy a set of search criteria.

GET /api/{Context}/Keywords

Specify a context (community) to indicate the data source. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the parameters in the table below to control how the result set displays the returned properties.

The result set contains the selected list of properties for Keywords satisfying the provided search criteria. The result set should include the "id" parameter to allow further operations, such as retrieving detailed information related to a Keyword of interest.

Try me in EqlExplorer
Try me in Swagger

Search Keyword Request Info

Search Keyword Request Parameters

Search Keyword Responses

Retrieving Keywords

$ curl https://datastorage.dev.aw-au.bentley.com/{Context}/Keywords/242?include={RetrieveOptions}
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function retrieveKeywords( host, id, retrieveOptions = 'Header') {
   let requestUrl = host + '/api/0/Keywords/id/?include=' + retrieveOptions;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

/* Sample request for Keyword */
{
  "addedBy": {
    "id": 999
  },
  "changedBy": {
    "id": 999
  },
  "dateAdded": "2020-09-10T12:09:03.5276104+01:00",
  "dateChanged": "2020-09-10T12:09:03.5277697+01:00",
  "id": 999,
  "name": "sample",
  "namespace": {
    "name": "sample",
    "id": 999
  },
  "scope": {
    "name": "sample",
    "id": 999
  }
}

Retrieves a single Keyword instance the properties of which are populated based on the request parameters.

This GET request method can retrieve more detailed information for the Keyword identified by its "id". The syntax for this form of the GET request is as follows.

GET /api/{Context}/Keywords/{id}

Use the "id" for the Keyword to retrieve, and specify a context (community) to narrow the search. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the "include" parameter to specify the properties returned in the result set. (Defaults to "Header").

The GET method returns the properties specified in the HTTP request header for the document copy identified by "id".

Try me in RetrieveExplorer
Try me in Swagger

Search Keyword Request Info

Retrieve Keyword Request Parameters

Retrieve Keyword Properties per include option.

RetrieveKeyword Responses

Creating Keywords

Try me in Swagger

Request Body (JSON)

{
  "name": "string value"
}

$ curl -X POST https://datastorage.dev.aw-au.bentley.com/{Context}/Keywords
-H "Accept: application/json"
-H "Authorization: Bearer {token}"
-d "see json request body"

// the modelPost structure is described in the Request Json 
async function postKeywords( host, modelPost) {
   let requestUrl = host + '/api/0/Keywords
   const init = {
      method: 'POST',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = modelPost.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

{
  "id": 999
}

The following methods are available for creating a new instance of Keyword.

1. Calling the API directly providing the required data.

2. Using a Template

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server. Set the "Authorization" parameter to a valid session bearer token.

Add Keyword Request Info

Post Keyword Contract Info

The POST request for Keyword contract has the following properties

Add Keyword Response Statuses

Changing Keywords

Try me in Swagger

Request Body (JSON)

{
  "name": "string value",
  "id": 999
}

$ curl -X PATCH https://datastorage.dev.aw-au.bentley.com/{Context}/Keywords
-H "Accept: application/json"
-H "Authorization: Bearer {token}"
-d "see json request"

// the modelPatch structure is described in the Request Json 
async function patchKeywords( host, id, modelPatch) {
   let requestUrl = host + '/api/0/Keywords/'+id
   const init = {
      method: 'PATCH',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = modelPatch.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Saves the modification on the Keyword instance to the database.

Try me in Swagger

Change Keyword Request Info

Patch Keyword Contract Info

The Keyword properties for a PATCH requests are:

Patch Keyword Responses

Deleting Keywords

Try me in Swagger

$ curl -X DELETE https://datastorage.dev.aw-au.bentley.com/{Context}/Keywords/123
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function DeleteKeywords( host, id) {
   let requestUrl = host + '/api/0/Keywords/+id+
   const init = {
      method: 'DELETE',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = model.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Deletes the Keyword instance from the database.

Delete Keyword Request Info

Delete Keyword Responses

Notes

Supported operations

Searching [GET] /api/{Context}/Notes

Retrieving [GET] /api/{Context}/Notes/{id}

Creating [POST] /api/{Context}/Notes

Changing [PATCH] /api/{Context}/Notes/{id}

Deleting [DELETE] /api/{Context}/Notes/{id}

A Note is a 'Dependent Object' which mean which mean that although it has most of the characteristics of an Object it depends on the existence of an Independent Object. If the 'parent' Object gets deleted it gets deleted too.

A Note may be created in any Scope .

The read-only Id property is the unique identifier. This identifier is assigned on creation and used in subsequent actions like Retrieve .

The ObjectType identifier for Note is 76.

The Note supports the instance permissions: View, Modify and Delete in addition to the Type permission that governs its creation.

You can use Note as the root [START WITH] type in a Search . A number of properties including: Object, Scope, Id, Name, Content, Priority etc. are available to the search. To find a full list of searchable properties use SearchableTypes .

Searching Notes

$ curl https://datastorage.dev.aw-au.bentley.com//api/{Context}/Notes/?include=Id,Name&filter=Id=1&startAt=0&pageSize=20
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function searchNotes( host, include= 'Id,Name', filter, order, startAt = 0, pageSize = 10) {
   let requestUrl = host + '/api/0/Notes?include=' + include +'&filter=' + filter +;&order=' + order +'&startAt=' + startAt + '&pageSize=' + pageSize;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

[
{
  "id": 998,
  "name": "sample"
},
{
  "id": 999,
  "name": "sample"
}
]

Enables Searching on Notes using the EQL logic.

Use the GET request method to search for Notes that satisfy a set of search criteria.

GET /api/{Context}/Notes

Specify a context (community) to indicate the data source. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the parameters in the table below to control how the result set displays the returned properties.

The result set contains the selected list of properties for Notes satisfying the provided search criteria. The result set should include the "id" parameter to allow further operations, such as retrieving detailed information related to a Note of interest.

Try me in EqlExplorer
Try me in Swagger

Search Note Request Info

Search Note Request Parameters

Search Note Responses

Retrieving Notes

$ curl https://datastorage.dev.aw-au.bentley.com/{Context}/Notes/242?include={RetrieveOptions}
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function retrieveNotes( host, id, retrieveOptions = 'Header') {
   let requestUrl = host + '/api/0/Notes/id/?include=' + retrieveOptions;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

/* Sample request for Note */
{
  "object": {
    "type": 999,
    "id": 999
  },
  "name": "sample",
  "addedBy": {
    "code": "sample",
    "surname": "sample",
    "initial": "sample",
    "firstName": "sample",
    "class": {
      "code": "sample",
      "name": "sample",
      "isSyncTracked": false,
      "id": 999
    },
    "isTemplate": true,
    "id": 999
  },
  "priority": {
    "priority": 999,
    "name": "sample",
    "id": 999
  },
  "content": "sample",
  "scope": {
    "name": "sample",
    "id": 999
  },
  "hasFlags": 9999,
  "permissionHint": 999,
  "dateAdded": "2020-09-10T12:09:03.5955067+01:00",
  "dateChanged": "2020-09-10T12:09:03.5955996+01:00",
  "changedBy": {
    "id": 999
  },
  "id": 999
}

Retrieves a single Note instance the properties of which are populated based on the request parameters.

This GET request method can retrieve more detailed information for the Note identified by its "id". The syntax for this form of the GET request is as follows.

GET /api/{Context}/Notes/{id}

Use the "id" for the Note to retrieve, and specify a context (community) to narrow the search. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the "include" parameter to specify the properties returned in the result set. (Defaults to "Header").

The GET method returns the properties specified in the HTTP request header for the document copy identified by "id".

Try me in RetrieveExplorer
Try me in Swagger

Search Note Request Info

Retrieve Note Request Parameters

Retrieve Note Properties per include option.

RetrieveNote Responses

Creating Notes

Try me in Swagger

Request Body (JSON)

{
  "object": {
    "type": 999,
    "id": 999
  },
  "name": "string value",
  "addedBy": {
    "id": 999
  },
  "priority": {
    "priority": 999
  },
  "content": "string value"
}

$ curl -X POST https://datastorage.dev.aw-au.bentley.com/{Context}/Notes
-H "Accept: application/json"
-H "Authorization: Bearer {token}"
-d "see json request body"

// the modelPost structure is described in the Request Json 
async function postNotes( host, modelPost) {
   let requestUrl = host + '/api/0/Notes
   const init = {
      method: 'POST',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = modelPost.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

{
  "id": 999
}

The following methods are available for creating a new instance of Note.

1. Calling the API directly providing the required data.

2. Using a Template

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server. Set the "Authorization" parameter to a valid session bearer token.

Add Note Request Info

Post Note Contract Info

The POST request for Note contract has the following properties

Add Note Response Statuses

Changing Notes

Try me in Swagger

Request Body (JSON)

{
  "name": "string value",
  "addedBy": {
    "id": 999
  },
  "priority": {
    "priority": 999
  },
  "content": "string value",
  "id": 999
}

$ curl -X PATCH https://datastorage.dev.aw-au.bentley.com/{Context}/Notes
-H "Accept: application/json"
-H "Authorization: Bearer {token}"
-d "see json request"

// the modelPatch structure is described in the Request Json 
async function patchNotes( host, id, modelPatch) {
   let requestUrl = host + '/api/0/Notes/'+id
   const init = {
      method: 'PATCH',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = modelPatch.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Saves the modification on the Note instance to the database.

Try me in Swagger

Change Note Request Info

Patch Note Contract Info

The Note properties for a PATCH requests are:

Patch Note Responses

Deleting Notes

Try me in Swagger

$ curl -X DELETE https://datastorage.dev.aw-au.bentley.com/{Context}/Notes/123
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function DeleteNotes( host, id) {
   let requestUrl = host + '/api/0/Notes/+id+
   const init = {
      method: 'DELETE',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = model.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Deletes the Note instance from the database.

Delete Note Request Info

Delete Note Responses

Intents

Supported operations

Searching [GET] /api/{Context}/Intents

Retrieving [GET] /api/{Context}/Intents/{id}

Creating [POST] /api/{Context}/Intents

Changing [PATCH] /api/{Context}/Intents/{id}

Deleting [DELETE] /api/{Context}/Intents/{id}

Searching Intents

$ curl https://datastorage.dev.aw-au.bentley.com//api/{Context}/Intents/?include=Id,Name,Code&filter=Id=1&startAt=0&pageSize=20
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function searchIntents( host, include= 'Id,Name,Code', filter, order, startAt = 0, pageSize = 10) {
   let requestUrl = host + '/api/0/Intents?include=' + include +'&filter=' + filter +;&order=' + order +'&startAt=' + startAt + '&pageSize=' + pageSize;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

[
{
  "code": "sample",
  "id": 998,
  "name": "sample"
},
{
  "code": "sample",
  "id": 999,
  "name": "sample"
}
]

Enables Searching on Intents using the EQL logic.

Use the GET request method to search for Intents that satisfy a set of search criteria.

GET /api/{Context}/Intents

Specify a context (community) to indicate the data source. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the parameters in the table below to control how the result set displays the returned properties.

The result set contains the selected list of properties for Intents satisfying the provided search criteria. The result set should include the "id" parameter to allow further operations, such as retrieving detailed information related to a Intent of interest.

Try me in EqlExplorer
Try me in Swagger

Search Intent Request Info

Search Intent Request Parameters

Search Intent Responses

Retrieving Intents

$ curl https://datastorage.dev.aw-au.bentley.com/{Context}/Intents/242?include={RetrieveOptions}
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function retrieveIntents( host, id, retrieveOptions = 'Header') {
   let requestUrl = host + '/api/0/Intents/id/?include=' + retrieveOptions;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

/* Sample request for Intent */
{
  "addedBy": {
    "id": 999
  },
  "changedBy": {
    "id": 999
  },
  "code": "sample",
  "dateAdded": "2020-09-10T12:09:03.7775915+01:00",
  "dateChanged": "2020-09-10T12:09:03.7777333+01:00",
  "description": "sample",
  "id": 999,
  "isEnabled": true,
  "name": "sample"
}

Retrieves a single Intent instance the properties of which are populated based on the request parameters.

This GET request method can retrieve more detailed information for the Intent identified by its "id". The syntax for this form of the GET request is as follows.

GET /api/{Context}/Intents/{id}

Use the "id" for the Intent to retrieve, and specify a context (community) to narrow the search. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the "include" parameter to specify the properties returned in the result set. (Defaults to "Header").

The GET method returns the properties specified in the HTTP request header for the document copy identified by "id".

Try me in RetrieveExplorer
Try me in Swagger

Search Intent Request Info

Retrieve Intent Request Parameters

Retrieve Intent Properties per include option.

RetrieveIntent Responses

Creating Intents

Try me in Swagger

Request Body (JSON)

{
  "code": "string value",
  "name": "string value",
  "description": "string value",
  "isEnabled": true
}

$ curl -X POST https://datastorage.dev.aw-au.bentley.com/{Context}/Intents
-H "Accept: application/json"
-H "Authorization: Bearer {token}"
-d "see json request body"

// the modelPost structure is described in the Request Json 
async function postIntents( host, modelPost) {
   let requestUrl = host + '/api/0/Intents
   const init = {
      method: 'POST',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = modelPost.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

{
  "id": 999
}

The following methods are available for creating a new instance of Intent.

1. Calling the API directly providing the required data.

2. Using a Template

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server. Set the "Authorization" parameter to a valid session bearer token.

Add Intent Request Info

Post Intent Contract Info

The POST request for Intent contract has the following properties

Add Intent Response Statuses

Changing Intents

Try me in Swagger

Request Body (JSON)

{
  "code": "string value",
  "name": "string value",
  "description": "string value",
  "isEnabled": true,
  "id": 999
}

$ curl -X PATCH https://datastorage.dev.aw-au.bentley.com/{Context}/Intents
-H "Accept: application/json"
-H "Authorization: Bearer {token}"
-d "see json request"

// the modelPatch structure is described in the Request Json 
async function patchIntents( host, id, modelPatch) {
   let requestUrl = host + '/api/0/Intents/'+id
   const init = {
      method: 'PATCH',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = modelPatch.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Try me in Swagger

Change Intent Request Info

Patch Intent Contract Info

The Intent properties for a PATCH requests are:

Patch Intent Responses

Deleting Intents

Try me in Swagger

$ curl -X DELETE https://datastorage.dev.aw-au.bentley.com/{Context}/Intents/123
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function DeleteIntents( host, id) {
   let requestUrl = host + '/api/0/Intents/+id+
   const init = {
      method: 'DELETE',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = model.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Delete Intent Request Info

Delete Intent Responses

Relationships

Relationships define links between AssetWise objects representing business entities. The DataStorage Service provides several types of inherent (built-in) relationships, including:

• Document to tag
• Person to organization
• Person to project
• Tag to physical item

Like the objects being linked, relationships belong to classes, have system (built-in) attributes, and can support custom attributes. Users can create custom relationships to meet their business requirements.

Searching Relationships

$ curl https://datastorage.dev.aw-au.bentley.com//api/{Context}/Relationships/?include=Id&filter=Id=1&startAt=0&pageSize=20
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function searchRelationships( host, include= 'Id', filter, order, startAt = 0, pageSize = 10) {
   let requestUrl = host + '/api/0/Relationships?include=' + include +'&filter=' + filter +;&order=' + order +'&startAt=' + startAt + '&pageSize=' + pageSize;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

[
{
  "id": 998
},
{
  "id": 999
}
]

Enables Searching on Relationships using the EQL logic.

Use the GET request method to search for Relationships that satisfy a set of search criteria.

GET /api/{Context}/Relationships

Specify a context (community) to indicate the data source. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the parameters in the table below to control how the result set displays the returned properties.

The result set contains the selected list of properties for Relationships satisfying the provided search criteria. The result set should include the "id" parameter to allow further operations, such as retrieving detailed information related to a Relationship of interest.

Try me in EqlExplorer
Try me in Swagger

Search Relationship Request Info

Search Relationship Request Parameters

Search Relationship Responses

Retrieving Relationships

$ curl https://datastorage.dev.aw-au.bentley.com/{Context}/Relationships/242?include={RetrieveOptions}
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function retrieveRelationships( host, id, retrieveOptions = 'Header') {
   let requestUrl = host + '/api/0/Relationships/id/?include=' + retrieveOptions;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

/* Sample request for Relationship */
{
  "scope": {
    "name": "sample",
    "id": 999
  },
  "guid": "00000000-0000-0000-0000-000000000000",
  "left": {
    "type": 999,
    "code": "sample",
    "revision": "sample",
    "scope": {
      "id": 999
    },
    "guid": "00000000-0000-0000-0000-000000000000",
    "id": 999
  },
  "right": {
    "type": 999,
    "code": "sample",
    "revision": "sample",
    "scope": {
      "id": 999
    },
    "guid": "00000000-0000-0000-0000-000000000000",
    "id": 999
  },
  "relationshipType": {
    "controlledBy": "sample",
    "guid": "00000000-0000-0000-0000-000000000000",
    "id": 999,
    "leftName": "sample",
    "presentation": "sample",
    "rightName": "sample"
  },
  "hasFlags": 9999,
  "permissionHint": 999,
  "isTemplate": true,
  "dateAdded": "2020-09-10T12:09:03.8331515+01:00",
  "addedBy": {
    "id": 999
  },
  "dateChanged": "2020-09-10T12:09:03.8332912+01:00",
  "changedBy": {
    "id": 999
  },
  "id": 999
}

Retrieves a single Relationship instance the properties of which are populated based on the request parameters.

This GET request method can retrieve more detailed information for the Relationship identified by its "id". The syntax for this form of the GET request is as follows.

GET /api/{Context}/Relationships/{id}

Use the "id" for the Relationship to retrieve, and specify a context (community) to narrow the search. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the "include" parameter to specify the properties returned in the result set. (Defaults to "Header").

The GET method returns the properties specified in the HTTP request header for the document copy identified by "id".

Try me in RetrieveExplorer
Try me in Swagger

Search Relationship Request Info

Retrieve Relationship Request Parameters

Retrieve Relationship Properties per include option.

RetrieveRelationship Responses

Scopes

Supported operations

Searching [GET] /api/{Context}/Scopes

Retrieving [GET] /api/{Context}/Scopes/{id}

Creating [POST] /api/{Context}/Scopes

Changing [PATCH] /api/{Context}/Scopes/{id}

Deleting [DELETE] /api/{Context}/Scopes/{id}

A Scope is classified as a 'Data Domain Definition' which mean that it purpose is to define the type and value of an attribute rather than being a significant object in itself.

The read-only Id property is the unique identifier. This identifier is assigned on creation and used in subsequent actions like Retrieve .

A Scope supports Namespace identification.

A Scope is unique across ( parent_id, name, object_id, object_type ).

The ObjectType identifier for Scope is 227.

The Scope does not support Instance Permission (i.e. Permission to View/Add/Change/Delete are granted accross all records of this Type).

You can use Scope as the root [START WITH] type in a Search . A number of properties including: Id, Name, Namespace, Owner, Parent, IsEnabled etc. are available to the search. To find a full list of searchable properties use SearchableTypes .

Searching Scopes

$ curl https://datastorage.dev.aw-au.bentley.com//api/{Context}/Scopes/?include=Id,Name&filter=Id=1&startAt=0&pageSize=20
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function searchScopes( host, include= 'Id,Name', filter, order, startAt = 0, pageSize = 10) {
   let requestUrl = host + '/api/0/Scopes?include=' + include +'&filter=' + filter +;&order=' + order +'&startAt=' + startAt + '&pageSize=' + pageSize;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

[
{
  "id": 998,
  "name": "sample"
},
{
  "id": 999,
  "name": "sample"
}
]

Enables Searching on Scopes using the EQL logic.

Use the GET request method to search for Scopes that satisfy a set of search criteria.

GET /api/{Context}/Scopes

Specify a context (community) to indicate the data source. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the parameters in the table below to control how the result set displays the returned properties.

The result set contains the selected list of properties for Scopes satisfying the provided search criteria. The result set should include the "id" parameter to allow further operations, such as retrieving detailed information related to a Scope of interest.

Try me in EqlExplorer
Try me in Swagger

Search Scope Request Info

Search Scope Request Parameters

Search Scope Responses

Retrieving Scopes

$ curl https://datastorage.dev.aw-au.bentley.com/{Context}/Scopes/242?include={RetrieveOptions}
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function retrieveScopes( host, id, retrieveOptions = 'Header') {
   let requestUrl = host + '/api/0/Scopes/id/?include=' + retrieveOptions;
   const init = {
      method: 'GET',
      headers: {
         Authorization: 'bearer {token}'
         }
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

/* Sample request for Scope */
{
  "parent": {
    "name": "sample",
    "id": 999
  },
  "name": "sample",
  "owner": {
    "type": 999,
    "label": "sample",
    "guid": "00000000-0000-0000-0000-000000000000",
    "id": 999
  },
  "namespace": {
    "name": "sample",
    "id": 999
  },
  "isEnabled": true,
  "guid": "00000000-0000-0000-0000-000000000000",
  "description": "sample",
  "dateAdded": "2020-09-10T12:09:03.9037888+01:00",
  "addedBy": {
    "id": 999
  },
  "dateChanged": "2020-09-10T12:09:03.9038903+01:00",
  "changedBy": {
    "id": 999
  },
  "dateUsed": "2020-09-10T12:09:03.903981+01:00",
  "usedBy": {
    "id": 999
  },
  "usageCount": 999,
  "hasData": "sample",
  "id": 999
}

Retrieves a single Scope instance the properties of which are populated based on the request parameters.

This GET request method can retrieve more detailed information for the Scope identified by its "id". The syntax for this form of the GET request is as follows.

GET /api/{Context}/Scopes/{id}

Use the "id" for the Scope to retrieve, and specify a context (community) to narrow the search. The default value "0" references the current context.

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server.

1. Set the "Authorization" parameter to a valid session bearer token.

2. Use the "include" parameter to specify the properties returned in the result set. (Defaults to "Header").

The GET method returns the properties specified in the HTTP request header for the document copy identified by "id".

Try me in RetrieveExplorer
Try me in Swagger

Search Scope Request Info

Retrieve Scope Request Parameters

Retrieve Scope Properties per include option.

RetrieveScope Responses

Creating Scopes

Try me in Swagger

Request Body (JSON)

{
  "parent": {
    "id": 999
  },
  "name": "string value",
  "owner": {
    "type": 999,
    "id": 999
  },
  "namespace": {
    "id": 999
  }
}

$ curl -X POST https://datastorage.dev.aw-au.bentley.com/{Context}/Scopes
-H "Accept: application/json"
-H "Authorization: Bearer {token}"
-d "see json request body"

// the modelPost structure is described in the Request Json 
async function postScopes( host, modelPost) {
   let requestUrl = host + '/api/0/Scopes
   const init = {
      method: 'POST',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = modelPost.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Response Body (JSON)

{
  "id": 999
}

The following methods are available for creating a new instance of Scope.

1. Calling the API directly providing the required data.

2. Using a Template

Before invoking the method, set up the HTTP request header as follows to pass the required parameters to the HTTP server. Set the "Authorization" parameter to a valid session bearer token.

Add Scope Request Info

Post Scope Contract Info

The POST request for Scope contract has the following properties

Add Scope Response Statuses

Changing Scopes

Try me in Swagger

Request Body (JSON)

{
  "name": "string value",
  "isEnabled": true,
  "owner": {
    "type": 999,
    "id": 999
  },
  "namespace": {
    "id": 999
  },
  "id": 999
}

$ curl -X PATCH https://datastorage.dev.aw-au.bentley.com/{Context}/Scopes
-H "Accept: application/json"
-H "Authorization: Bearer {token}"
-d "see json request"

// the modelPatch structure is described in the Request Json 
async function patchScopes( host, id, modelPatch) {
   let requestUrl = host + '/api/0/Scopes/'+id
   const init = {
      method: 'PATCH',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = modelPatch.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Saves the modification on the Scope instance to the database.

Try me in Swagger

Change Scope Request Info

Patch Scope Contract Info

The Scope properties for a PATCH requests are:

Patch Scope Responses

Deleting Scopes

Try me in Swagger

$ curl -X DELETE https://datastorage.dev.aw-au.bentley.com/{Context}/Scopes/123
-H "Accept: application/json"
-H "Authorization: Bearer {token}"

async function DeleteScopes( host, id) {
   let requestUrl = host + '/api/0/Scopes/+id+
   const init = {
      method: 'DELETE',
      headers: {
         Authorization: 'bearer {token}'
         },
      body = model.json()
      }
   return (await fetch(requestUrl, init)).json();
}

Deletes the Scope instance from the database.

Delete Scope Request Info