CA Live API Creator 3.2

5.4 5.3 5.2 5.1 5.0 4.1 4.0 3.2 3.1.1 3.1
English

System REST Endpoints

You can retrieve information about an API, such as the list of entities and resources and their attributes, rather than actual data, using the system REST endpoints that  provides.  provides these endpoints as metadata services.
lac32
You can retrieve information about an API, such as the list of entities and resources and their attributes, rather than actual data, using the system REST endpoints that 
CA Live API Creator
 provides. 
CA Live API Creator
 provides these endpoints as metadata services.
Prerequisite: 
You have access to meta table REST endpoints.
For more information about how to grant roles permissions to meta table REST endpoints, see Role-Based Endpoint Access.
The examples shown in this article assume that you are sending an auth token with the request, either in the URL (with the 
auth
 parameter) or (more commonly) in the 
Authorization
 header.
In this article:
 
4
GET @data_sources
You can retrieve a list of active data sources for the current API using the 
@data_sources
 endpoint:
GET @data_sources
 Only auth tokens that have a role with a permission for the 
@metatables
 pseudo-table can call this endpoint.
Response
 
The following response is expected:
[  {
     "name": "Finance",
      "ident": 2009,
      "prefix": "finance",
      "comments": null,
      "schema_editable": false
  },
  {
      "name": "New database qjtea",
      "ident": 2159,
      "prefix": "qjtea",
      "comments": null,
      "schema_editable": true
  }
]
GET @schema/[datasource_prefix]?projectId=123
The 
@schema
 endpoint can represent specific data source content, such as entities, columns, keys, and relationships. You can retrieve a list of all data source content that you can use to create a new schema by calling the 
@schema
 REST endpoint for a managed data API:
GET @schema/[datasource_prefix]?projectId=123
If you use this endpoint in REST Lab, then the prefix must be one in the current API and the 
projectId
 is optional. If you make this call from an admin endpoint, then the 
projectId
 is required.
Schema Definition
 
Schema is an array of JSON objects for each entity (table) definition. Each table in the schema contains the following:
JSON Object
Description
entity
Entity name
primaryKeyColumns
An array of column string names.
columns
An array of columns in JSON.
Attributes:
  • name
     
  • generic_type
    Values:
     
    string
    , 
    int
    , 
    boolean
    , 
    number
    , 
    date
    , 
    datetime
    , or 
    text
     
  • size
     
  • nullable
     
  • subtype
    Values:
     
    integer
     or 
    fixedPoint
     (uses 
    precision
     and 
    scale
     columns)
    Optional:
     Yes
  • db_column_type
    This attribute specifies that you want to import the schema from within the same database type. If you want to port a schema from one database to another, select the 
    Ignore DB Column Type
     option during schema import or specify the parameter 
    ignoredbcolumntype=true
     in the URL.
    Optional:
     Yes
  • precision
    Optional:
     Yes
  • length
    Optional:
     Yes
  • scale
    Optional:
     Yes
relationships
An array of relationships in JSON.
Attributes:
 
  • relationship_name
     
  • parent_entity
    .
  • parent_column_names
     array of strings
    Optional: 
    Yes
  •  
    child_column_names
     array of strings
    Optional: 
    Yes
    To provide the column names, override this default behavior using the 
    enable_column_creation: false|true
     property, which defaults to 
    true
    .
keys
A collection of primary and candidate keys with each containing the 
name, type
 (primary|candidate), 
columns
 (array of string names) attributes.
Advanced Options
 
The following properties default to 
false
 if flag is not present:
  • ignoredbcolumntype=true|false
    Use 
    generic_type
     and subtype instead of 
    db_column_type
    .
  • ignoreprimarykeyname=true|false
    Ignore the provided primary key name and generate a new name.
  • ignoreconstraintname=true|false
    Ignore the provided relationship constraint name in parents and generate a new name.
    This property uses the prefix of the selected API. You must set the 
    isEditable
     data source property to 
    true
    . You can only call this property using an admin endpoint, for example:
    /rest/abl/admin/v2/@schema
POST @schema/[datasource_prefix]?projectId=123[&advanced options]
You can create a new schema using the following 
@schema
 managed data REST endpoint:
POST @schema/[datasource_prefix]?projectId=123[&advanced options]
Prerequisite:
 The prefix must belong to a data source that is marked as editable.
Payload
 
Use the following request payload:
{
"entity": "LineItem",
"primaryKeyColumns": [
    "lineitem_id"
],
"columns": [
{
   "name": "lineitem_id",
   "generic_type": "number",
   "nullable": false,
   "subtype": "integer",
   "autonum": true
},
{
   "name": "product_number",
   "generic_type": "number",
   "nullable": false,
   "subtype": "integer"
},
{
   "name": "order_number",
   "generic_type": "number",
   "nullable": false,
   "subtype": "integer"
},
{
   "name": "qty_ordered",
   "generic_type": "number",
   "nullable": false,
   "subtype": "integer"
},
{
   "name": "product_price",
   "generic_type": "number",
   "size": 19,
   "nullable": true,
   "subtype": "fixedPoint",
   "precision": 19,
   "scale": 4
},
{
   "name": "amount",
   "generic_type": "number",
   "size": 19,
   "nullable": true,
   "subtype": "fixedPoint",
   "precision": 19,
   "scale": 4
}
],
"parents": [
{
   "relationship_name": "product",
   "parent_entity": "demo:product",
   "parent_column_names": [
   "product_number"
],
"child_column_names": [
      "product_number"
  ]
},
{
   "relationship_name": "lineitem_purchaseorder",
   "parent_entity": "demo:PurchaseOrder",
   "parent_column_names": [
      "order_number"
  ],
  "child_column_names": [
     "order_number"
  ]
}
],
"keys": [
{
   "name": "SQL160918190322330",
  "type": "primary",
  "columns": [
      "lineitem_id"
   ]
  }
 ]}
Response
 
The following response is expected: 
{
 "status": 201,
 "prefix": [datasource_prefix],
 "number_tables": 7,
 "number_columns": 35,
 "number_relationships": 6
}
GET @tables
You can retrieve a list of all tables in an API using the following 
@tables
 managed data REST endpoint:
GET @tables
The API key in question must have access to the resource in question. For example, if you want to retrieve the list of all tables for an API, your API key must have a role with a permission for the 
@tables
 pseudo-table. You can retrieve full information for a table using the href URL or retrieve full information for all table information using "*".
URL
 
https://server.acme.com/rest/acme/myproject/v1/@tables
Response
 
The following response is expected:
[
  {
    "@metadata": {
    "href": "https://api.acme.com/rest/acme/myproject/v1/@tables/main:customer"
  },
  "prefix": "main",
  "entity": "customer",
  "name": "main:customer"
  },
  {
    "@metadata": {
      "href": "https://api.acme.com/rest/acme/myproject/v1/@tables/main:lineitem"
    },
    "prefix": "main",
    "entity": "lineitem",
    "name": "main:lineitem"
  }
]
GET @tables/[
prefix]
:[
tablename]
 
After you have retrieved the list of tables in an API using the 
@tables
 managed data REST endpoint, you can retrieve a specific line item in a table by following one of the returned href links.
URL
 
https://server.acme.com/rest/acme/demo/v1/@tables/[prefix]:[tablename]
Response
 
The following response is expected:
{  "@metadata":  {
    "href": "http://localhost:8080/rest/default/demo/v1/@tables/[prefix]:[tablename]"
  },
  "prefix": "demo",
  "entity": "customer",
  "name": "demo:customer",
  "primaryKeyColumns": [
    "name"
  ],
  "columns": [
  {
      "name": "name",
      "type": "VARCHAR",
      "generic_type": "string",
      "size": 30,
      "datetime_precision": -1,
      "nullable": false,
      "db_column_type": "VARCHAR(30)",
      "length": 30,
      "fixed_size": false,
      "computed": false,
      "is_editable": true,
      "dbName": ""name"",
      "persistent": true
   },
   {
      "name": "balance",
      "type": "DECIMAL",
      "generic_type": "number",
      "size": 19,
      "scale": 4,
      "datetime_precision": -1,
      "nullable": true,
      "db_column_type": "DECIMAL(19,4)",
      "subtype": "fixedPoint",
      "precision": 19,
      "computed": true,
      "is_editable": false,
      "dbName": ""balance"",
      "persistent": true    },
   {
      "name": "credit_limit",
      "type": "DECIMAL",
      "generic_type": "number",
      "size": 19,
      "scale": 4,
      "datetime_precision": -1,
      "nullable": false,
      "db_column_type": "DECIMAL(19,4)",
      "subtype": "fixedPoint",
      "precision": 19,
      "computed": false,
      "is_editable": true,
      "dbName": ""credit_limit"",
      "persistent": true
    }
  ],
  "parents": [],
  "children": [
    {
      "name": "financeOrders",
      "child_table": "finance:orders",
      "child_columns": [
        "customer_name"
      ],
      "parent_columns": [
        "name"
      ]
    },
    {
      "name": "PurchaseOrderList",
      "child_table": "demo:PurchaseOrder",
      "child_columns": [
        "customer_name"
      ],
      "parent_columns": [
        "name"
      ]
    }
  ],  "keys": [
    {
      "name": "SQL160816043234940",
      "type": "primary",
      "columns": "name"
    }
  ]
}
POST @tables/[
prefix
]?projectId=[
123
]
Prerequisites:
 
  • You are logged in to API Creator with the Data designer role.
  • The data source in which you want to add a table is marked as editable.
    For more information about how to mark a data source as editable, see Manage Existing Schemas.
You can add a new table in the data source that was defined using the following
@tables
 managed data REST endpoint and the response from the 
@databases
 endpoint:
POST @tables/[prefix]?projectId=[123]
Payload
 
Use the following request payload:
{
  "entity": "
[mynewtable]
"
}
Response
 
The following response is expected:
{  "@metadata": {
    "href": "http://localhost:8080/rest/default/demo/v1/@tables/demo:customer"
  },
  "prefix": "demo",
  "entity": "customer",
  "name": "demo:customer",
  "primaryKeyColumns": [
    "ident"
  ],
  "columns": [
    {
      "name": "name",
      "type": "VARCHAR",
      "generic_type": "string",
      "size": 30,
      "datetime_precision": -1,
      "nullable": false,
      "db_column_type": "VARCHAR(30)",
      "length": 30,
      "fixed_size": false,
      "computed": false,
      "is_editable": true,
      "dbName": ""name"",
      "persistent": true,
      "autonum": true
    }
  ],
  "parents": [ ],
  "children": [ ],
  "keys": [
    {
      "name": "PRIMARY",
      "type": "primary",
      "columns": "ident"
    }
  ]
}
The table is added in the database. API server recognizes this new table as valid after the schema is reloaded.
 
PUT @tables/[prefix]:[tablename]?projectId=[
123]
 
 
Prerequisite: 
The data source in which you want to update a table is marked as editable.For more information about how to mark a data source as editable, see Manage Existing Schemas.You can update a table name in the data source using the following 
@tables
 managed data REST endpoint:
PUT @tables/[prefix]:[tablename]?projectId=[
123]
If you are using multiple databases, prefix your table name with the database name (for example 
main:Customer
).
Payload
 
Use the following request payload:
{
 "@metadata":{
 "href":"http://<host>:<port>/rest/abl/admin/v2/@tables/[prefix]:[tablename]?projectId=[123]"
 },
 "entity":"
[new tablename]
",
}
DELETE @tables/[prefix]:[tablename]?projectId=[
123]
 
Prerequisites:
 
  • You are logged in to API Creator with the Data designer role.
    For more information about this role, including all of the roles for creating databases and managing tables, see Database Creation.
  • The data source in which you want to delete a table is marked as editable.For more information about how to mark a data source as editable, see Manage Existing Schemas.
You can delete a table in the data source using the following 
@tables
 managed data REST endpoint:
DELETE @tables/[prefix]:[tablename]?projectId=[123]
POST @columns/[prefix]:[tablename]?projectId=[
123
]
Prerequisites:
 
  • You are logged in to API Creator with the Data designer role.
    For more information about this role, including all of the roles for creating databases and managing tables and fields, see Database Creation.
  • The data source is marked as editable.For more information about how to mark a data source as editable, see Manage Existing Schemas.
You can create a field in an existing table in the data source using the following 
@columns
 managed data REST endpoint:
POST @columns/[prefix]:[tablename]?projectId=[123]
Use the prefix and table name to know which database the original table was defined. The valid 
generic_types
 are (string, text, int, decimal, number, date, datetime).
Fields represent the columns in your database. The term field is used to stay within the metaphor of applications and screens, and not database terminology.
 
Payload
 
Use the following request payload:
{
  "generic_type":"text",
  "name":"
[mynewtable_text]
",
  "size":16777216,
  "nullable":true
}
PUT @columns/[prefix]:[tablename]/[columnname]?projectId=[123]
Prerequisites:
 
  • You are logged in to API Creator with the Data designer role.
    For more information about this role, including all of the roles for creating databases and managing tables and fields, see Database Creation.
  • The data source to is marked as editable.
You can modify a field that represents a column in your database in an existing table in the data source using the following 
@columns
 managed data REST endpoint:
PUT @columns/[prefix]:[tablename]/[columnname]?projectId=[123]
Fields represent the columns in your database. The term field is used to stay within the metaphor of applications and screens, and not database terminology.
Payload
 
Use the following request payload:
{
  "name": "[
new_column_name]
",
}
DELETE @columns/[prefix]:[tablename]/[columnname]?projectId=[
123
]
You can delete a field in an existing table in the data source using the following 
@columns
 managed data REST endpoint:
DELETE @columns/[prefix]:[tablename]/[columnname]?projectId=[123]
Fields represent the columns in your database. The term field is used to stay within the metaphor of applications and screens, and not database terminology.
Prerequisites:
 
  • You are logged in to API Creator with the Data designer role.
  • The data source is marked as editable.
GET @databases?managed_data_server_ident=
12345
 
You can retrieve the list of managed databases existing on a managed data server using the following 
@databases
 managed data REST endpoint:
GET @databases?managed_data_server_ident=12345
Prerequisites:
 
  • You have an existing managed data server.
  • You are logged in to API Creator with the Data designer role.
    For more information about this role, including all of the roles for creating databases and managing tables and fields, see Database Creation.
 
Response
 
The following response is expected:
{
  "status": "OK",
  "number_databases": 2,
  "databases": [
    {
      "database_name": "bsfst",
      "number_objects": "47"
    },
    {
      "database_name": "cpkub",
      "number_objects": "6"
    }
  ]
}
Each entry reflects a database/schema in the server. The 
number_objects
 attribute shows the approximate number of tables and views in the database. This is meant to be a rough indication of the size of the database.
POST @databases
Prerequisites:
 
  • You have an existing managed data server.
  • You are logged in to API Creator with the Data designer role.
    For more information about this role, including all of the roles for creating databases and managing tables and fields, see Database Creation.
You can create a new SQL database using the following 
@databases
 managed data REST endpoint by passing the 
ident
 of the specific server:
POST @databases
Payload
 
Use the following request payload:
{ 
  "managed_data_server_ident": 2000
}
Response
 
The following response is expected:
{ 
    "status": "OK", 
    "url": "jdbc:mysql://dbserver.acme.com:3306/wcwqj", 
    "name": "wcwqj", 
    "catalog_name": null, 
    "schema_name": "wcwqj", 
    "user_name": "wcwqj", 
    "password": "IotMPl14w0zx", 
    "dbasetype_ident": 1 
}
Information about the new SQL database that was created in the managed data server is returned. You can create a new data source (DBSchema) using this information.
DELETE @databases/databasename?managed_data_server_ident=2000
Prerequisite:
 You are logged in to API Creator with the Data designer role.
You can delete a managed database using the following 
@databases
 managed data REST endpoint by providing the database name and the managed server 
ident
 value:
DELETE @databases/databasename?managed_data_server_ident=2000
For more information about the Data designer role, including all of the roles for creating databases and managing tables and fields, see Database Creation.
GET @relationships
You can get a list of relationship role names using the following 
@relationships
 REST endpoint:
@relationships/childTable=demo:PurchaseOrder
 or 
@relationships/parentTable=demo:Employee
POST @relationships/[prefix]:[tablename]?projectId=[
123
]
You can create a parent/child relationship between two tables using the following 
@relationships
 managed data REST endpoint. Provide the prefix (that belongs to a data source) and the name of the child table using the following syntax:
POST @relationships/[prefix]:[tablename]?projectId=[123]
Prerequisites:
 
  • You are logged in to API Creator with the Data designer role.
  • The data source is marked as editable.For more information about how to mark a data source as editable, see Manage Existing Schemas.
By default, if you do not pass in parent and child column names, 
CA Live API Creator
 creates them automatically using the parent primary key (usually 
ident
) and creates a new field on the child table using the name of the relationship plus the name of the primary key. If you intend to provide the column names, you can override this default behavior using 
enable_column_creation: false
 in the payload. With this payload, 
CA Live API Creator
 attempts to use your provided column names instead, using a lookup of the attribute name(s). If the attribute names are incorrect, the an error is returned.
Payload
 
Use the following request payload:
{
"parent_entity":"Parent!",
"relationship_name":"FooBar"
} 
optional field(s):
enable_column_creation: [true | false] (default: true)
"enable_column_creation": false,
"child_column_names": [
"FooBar_ident"
],
"parent_column_names": [
"ident"
]
Response
 
The following response is expected:
{
 "status": "OK",
"child_entity": "uqhee:Child!!",
"parent_entity": "uqhee:Parent!",
"child_column_names": [
"FooBar_ident"
],
"parent_column_names": [
"ident"
],
"relationship_name": "FooBar",
"children_role_name": "FooBar_Child$0021$0021_List",
"parent_role_name": "FooBar_Parent$0021",
"constraint_name": "FK_FooBar_$6486$"
}
 
DELETE @relationships/[prefix]:[tablename]/relationshipname?projectId=123
You can remove a relationship between a parent and child table based on the relationships role name using the following 
@relationships
 managed data REST endpoint by providing the table prefix+name for the table:
DELETE @relationships/prefix:tablename/relationshipname?projectId=123&enableDeleteColumns=true
The relationship role name can be the name to the parent or the name to the child. You can allow API Creator to remove the related foreign key column using the url 
?enableDeleteColumns=true
. By default, this value is set to false and API Creator does not delete columns.
Prerequisite:
 You are logged in to API Creator with the Data designer role.
For more information about this role, including all of the roles for creating databases and managing tables and fields, see Database Creation.
Response
 
The following response is expected:
{ 
    "status": "OK"
}
GET @resources[/ident]
You can use similar built-in resources for resources. You can retrieve all resources for the current API using the following 
@resource
 REST endpoint:
GET @resources[/ident]
You can retrieve full information for a resource using the href URL or retrieve full information for all resources using "*".
URL
https://api.acme.com/rest/acme/myproject/v1/@resources
Response
The following response is expected:
[
  {
    "@metadata": {
      "href": "http://api.acme.com/rest/acme/myproject/v1/@resources/2099"
     },
      "ident": 2099,
      "name": "ProfileAccounts",
       "apiVersion": "v1",
       "functions": [],
       "description": null,
       "resource_type": "NORMAL"
   }
]
The 
href
 provides a link to retrieve details about the specific resource.
GET @functions
You can retrieve all functions for the current API using the following
@functions
 RESTful endpoint:
GET @functions
A list of function definition objects will result, looking like:
[
  {
    "@metadata": {
      "href": "http://liveapicreatorurl.com/rest/default/demo/v1/@functions/2004"
    },
    "ident": 2004,
     "name": "tableResourceParameterizedFunc",
     "comments": "This is a skeleton function, you should most likely:\n1 - Give it a proper name (the default is a randomly generated 5-letter name)\n2 - Give it a proper comment\n3 - Change the code to do something useful",
     "is_active": true,
     "resource_names": [
       "AllCustomers",
       "demo:customer"
     ],
     "parameters": [
       {
        "name": "qmzfv",
         "type": "string",
         "is_required": false
       }
     ]
  }
]
GET @views[/view_name]
You can retrieve all views for the current API using the following 
@views
 RESTful endpoint:
GET @views[/view_name]
A list of all views for the selected project id is returned. You can retrieve details about the view itself by providing the view name (found in the 
href
 of the metadata).
URL
 
https://api.acme.com/rest/acme/demo/v1/@views?projectId=[1234]
POST @authentication
You can authenticate a user and obtain an auth token using the following 
@authentication
 RESTful endpoint:
POST @authentication
For more information about authentication, see Authentication.
GET @procedures
You can retrieve metadata about stored procedures using the following 
@procedures
 RESTful endpoint:
GET @procedures
The option 
procname
 retrieves details about the procedure itself.
URL
https://api.acme.com/rest/acme/demo/v1/@procedures?projectId=[1234]
Response
 
The following response is expected:
[
  {
    "@metadata": {
      "href": "https://api.acme.com/rest/acme/demo/v1/@procedures/[prefix]:[entity]?projectId=[1234]"
    },
    "prefix": "[prefix]",
    "entity": "[entity]",
    "name": "demo:get_employee"
  },
  {
    "@metadata": {
      "href": "https://api.acme.com/rest/acme/demo/v1/@procedures/demo:promote_employee?projectId=1234"
    },
    "prefix": "demo",
    "entity": "promote_employee",
    "name": "demo:promote_employee"
  }
]
 
GET @procedures[/
procedure_name
]
After you have retrieved the metadata about stored procedures using the 
@procedures
 endpoint, you can retrieve full information on a procedure by doing a GET against that procedure's URL:
GET @procedures[/procedure_name]
 
Response
 
The following response is expected:
{
  "@metadata": {
    "href": "https://api.acme.com/rest/acme/demo/v1/@procedures/[prefix]:[entity]?projectId=[1234]"
  },
  "prefix": "[prefix]",
  "entity": "[entity]",
  "name": "demo:get_employee",
  "args": [
    {
      "name": "given_employee_id",
      "type": "BIGINT",
      "direction": "IN"
    },
    {
      "name": "plus_one",
      "type": "BIGINT",
      "direction": "IN_OUT"
    }
  ]
}
GET @sequences
You can retrieve a list of all the database sequences in use using the following 
@sequences
 RESTful endpoint:
GET @sequences
This call returns an empty array except for those databases that support sequences (like Oracle).
GET @perf
You can retrieve an object containing pointers to the performance statistics using the following 
@perf
 RESTful endpoint:
GET @perf
For more information about the performance metrics, see Analyze Metrics.
GET @perf[[rules | sql | adminSql]?projectId=[2000]
You can retrieve performance statistics for a specific API using the 
@perf
 endpoint:
GET @perf[[rules | sql | adminSql]?projectId=[2000]
This call returns the following statistics:
  • Execution of rules.
  • Execution of SQL for your database(s).
  • Execution of SQL for the admin database.
Response
 
The following response is expected:
 
{
  "meta": {
    "currentTime": 42132335320569
  },
  "stats": [
    {
      "rule": {
        "ident": 2000,
        "entity": "demo:customer",
        "type": "validation",
        "name": "Validation return row.balance <= row.credit_limit;"
        },
      "firstExecutionTime": 37501167023156,
       "lastExecutionTime": 37501167023156,
      "shortestExecutionTime": 1585839,
       "longestExecutionTime": 1585839,
       "numberOfExecutions": 1,
       "totalExecutionTime": 1585839
    },
    {
       "rule": {
         "ident": 2002,
         "entity": "demo:customer",
         "type": "sum",
         "name": "Derive balance as sum(PurchaseOrderList.amount_total where paid = false)"
         },
       "firstExecutionTime": 37501164919658,
       "lastExecutionTime": 37501164919658,
       "shortestExecutionTime": 1437219,
       "longestExecutionTime": 1437219,
       "numberOfExecutions": 1,
       "totalExecutionTime": 1437219
    },
    {
       "rule": {
        "ident": 2005,
        "entity": "demo:PurchaseOrder",
        "type": "event",
        "name": "Audit Purchase Order amount changes"
       },
       "firstExecutionTime": 37501158809963,
       "lastExecutionTime": 37501158809963,
       "shortestExecutionTime": 10199279,
       "longestExecutionTime": 10199279,
       "numberOfExecutions": 1,
       "totalExecutionTime": 10199279
   }
 ]
GET @serverinfo
You can retrieve information about the server it reached using the following 
@serverinfo
 RESTful endpoint:
GET @serverinfo
Response
 
The following response is expected:
{  "publicAddress": "12.34.56.78",
  "hostname": "api.acme.com",
  "osName": "Linux 2.8",
  "currentDateTime": "2015-11-10T01:19:27.539Z",
  "numCores": 8,
  "freeMemory": 263916512,
  "maxMemory": 3817865216,
  "totalMemory": 632291328,
  "uptime": 621827,
  "loadAverage": 2.48974609375,
  "adminSchemaVersion": "20151106",
  "serverVersion": "2.0"
}
GET @dependencies
You can retrieve dependencies information using the following 
@dependencies
 RESTful endpoint:
GET @dependencies
 
Response
 
The following response is expected:
[{
 "tableName": "LOGICDEMO."LineItem"",
 "dependencies": [
 {
   "ruleName": "Discounted price*qty",
   "columnName": "amount",
   "dependsOn": "product_price"
 },
 {
   "ruleName": "Discounted price*qty",
   "columnName": "amount",
   "dependsOn": "qty_ordered"
 },
 {
   "ruleName": "Derive product_price as parentcopy(product.price)",
   "columnName": "product_price",
   "roleName": "product",
   "dependsOn": "price"
 }  }, more...
]
GET @docs
You can retrieve a Swagger document about the API using the following 
@docs
 RESTful endpoint:
GET @docs
 
Response
 
The following response is expected:
{
  "swaggerVersion": "1.2",
  "consumes": [
  "application/json"
  ],
  "produces": [
    "application/json"
  ],
  "apiVersion": "v1",
  "info": {
    "title": "Northwind",
    "description": "Simple order processing demo"
  },
  "authorizations": {
    "Admin key": {
      "type": "apiKey",
      "passAs": "header",
      "keyname": "Authorization"
    }
  },
  "apis": [
    {
      "path": "/CustomersBusObject",
      "description": "resource"
    },
    {
      "path": "/EmployeesObject",
      "description": "resource"
    },
etc...
GET @rules[/ident]
You can retrieve a high-level list of API defined logic rules using the following 
@rules
 RESTful endpoint:
GET @rules[/ident]
Response
 
The following response is expected:
[
  {
  "@metadata": {
    "href": "https://api.acme.com/rest/default/demo/v1/@rules/2000"
  },
  "ident": 2000,
  "bestName": "Validation return row.Balance <= row.CreditLimit;",
  "name": "",
  "entityName": "nw:Customers",
  "columnName": null,
  "comments": "Observe Error message insertion points {}"
},
{
  "@metadata": {
    "href": "https://api.acme.com/rest/default/demo/v1/@rules/2001"
  },
  "ident": 2001,
  "bestName": "adjust the balance to be the sum(OrdersList.AmountTotal) for unshipped orders",
  "name": "adjust the balance to be the sum(OrdersList.AmountTotal) for unshipped orders",
  "entityName": "nw:Customers",
  "columnName": null,
  "comments": "Adjusts Balance by *reacting* to changes in OrdersList.AmountTotal, including other changes noted in Table/Column help."
},
etc...
GET @metatables
You can retrieve a list of most of the APIs listed on this page using the following 
@metatables
 RESTful endpoint:
GET @metatables
Response
The following response is expected:
[
{
"@metadata": {
"href": "https://api.acme.com/rest/default/demo/v1/@tables"
},
"name": "@tables"
},
{
"@metadata": {
"href": "https://api.acme.com/rest/default/demo/v1/@views"
},
"name": "@views"
},
{
"@metadata": {
"href": "https://api.acme.com/rest/default/demo/v1/@procedures"
},
"name": "@procedures"
},
{
"@metadata": {
"href": "https://api.acme.com/rest/default/demo/v1/@resources"
},
"name": "@resources"
}
]
GET @auth_provider_info[/ident]
You can retrieve the detail configuration values for this plugin identity manager using the following 
@auth_provider_info
 endpoint by passing in the 
ident
 of a specific authentication provider: 
GET @auth_provider_info[/ident]
GET @login_info
You can create a login dialog by retrieving the default values used by the authentication provider using the following 
@login_info
 endpoint:
GET @login_info
For more information about authentication, see Authentication.
GET @apps[/appid]
You can retrieve a list of the applications and definitions (table settings and skins) for the 
appid
 you identify using the following 
@apps
 endpoint:
GET @apps[/appid]
Response
 
The following response is expected:
[
  {
    "@metadata": {
      "href": "http://api.acme.com/rest/default/sample/v1/@apps/2000"
  },
  "ident": 2000,
  "name": "Default app",
  "description": null
  }
]
GET @eula[/eula_code]
You can retrieve the End User License Agreement (EULA), which supports multiple languages, using the following 
@eula
 endpoint:
GET @eula[/eula_code]
URL
GET https://api.acme.com/rest/default/demo/v1/@eula/ENU
Response
The following response is expected:
"eula_code": "ENU",
 "eula_accepted": true,
 "eula_accepted_code": "ENU",
 "eula_acceptance_detail": "accepted ENU 2016-07-14T18:54:28Z",
 "eula": "CA End User License Agreement (the "Agreement") ... truncated
POST @eula
You can accept the end-user license agreement using the API using the
@eula
 endpoint: 
POST @eula
Response
The following response is expected:
{"eula_accepted": true, "eula_code": "ENU"}
GET @license
You can retrieve a value that depends on whether the call includes an auth token (is authenticated) or not using the 
@license
 endpoint:
GET @license
URL
 
GET https://api.acme.com/rest/default/demo/v1/@license
Response
 
If the call includes an auth token, the following response is expected:
{
  "company": "Acme Corp.",
  "organization": "Accounting",
  "location": "New York, NY, USA",
  "license_type": "PRODUCTION",
  "license_expiration": "2017-12-31T23:59:59.999Z",
  "product_version": "2",
  "max_cores": 8,
  "max_memory": 1024,
  "max_projects": 0,
  "max_requests": 0,
  "max_resources": 0,
  "max_rules": 0,
  "eula": "Lorem ipsum etc..."
}
If the call does not include an authentication token, the following response is expected:
{
  "company": "Acme Corp.",
  "organization": "Accounting",
  "location": "New York, NY, USA",
  "license_type": "PRODUCTION",
  "license_expiration": "2017-12-31T23:59:59.999Z"
}
GET @heartbeat
You can retrieve the server status using the 
@heartbeat
 endpoint:
GET @heartbeat
 
URL
 
GET https://api.acme.com/rest/default/demo/v1/@heartbeat
Response
The following response is expected:
{     "status": "OK"}
If the value of status is anything but 
OK
, then the server is not feeling well. Otherwise, the server is most likely OK.
GET @apioptions
You can retrieve a list of the API options for the current API, including the option's name and value, using the 
@apioptions
 endpoint:
GET @apioptions
URL
 
GET https://api.acme.com/rest/default/myproj/v1/@apioptions
 
Response
 
The following response is expected:
{
  "1": {
    "name": "Aggregate Default Override",
    "option_value": "false"
       },
  "2": {
     "name": "Type base URI",
     "option_value": "urn:caliveapicreator:demo:"
       },
  "3": {
     "name": "HTTPS only",
     "option_value": "false"
       },
etc...
where the key (for example, 1, 2, 3) is the ID of the option type (the name is the human-readable equivalent).
Script the Meta Tag Information
You can script the meta tag information using the command line interface (CLI). For a complete list, download the  file.
The following code snippet shows the contents of this file:
#! /bin/bash
# Uses NodeJS and the command line interface
# npm install liveapicreator-cli -g
# Live API Creator meta @ rest endpoints
#echo 1
# Note that the URL contains the entire path to the project 
lac login -u demo -p Password1 http://localhost:8080/APIServer/rest/default/nwindb2b/v1 -a localnw
lac use localnw
#Show the current license info (add --format json) for full EULA
lac get @license
#returns OK if server is up
lac get @heartbeat
# Show All Tables and columns for selected table
lac get @tables
lac get @tables/nw:Customers
# Show All views and columns for selected view
lac get @views
lac get @views/nw:Current%20Product%20List
# Show All Resoures and attribute for selected resources (using ident)
lac get @resources
lac get @resources/2961
# Show All Store Proc and attribute for selected proc (using ident)
lac get @procedures
#lac get @procedures/somename
#Show the performance metrics for sql, rules, and admin SQL (add --format json) for detailed view
lac get @perf --format json
lac get @perf/sql?projectId=2047
lac get @perf/rules?projectId=2047 
lac get @perf/adminSql?projectId=2047 
# Swagger 1.2 doc format
lac get @docs
lac get @docs/nw:Customers
#List of Rules
lac get @rules
#API settings
lac get @apioptions
#Information on the default auth provider
lac get @auth_provider_info/1000
#Information from the Auth Provider
lac get @login_info
For more information about the CLI, including how to install it and how to use it, see Install NodeJS.