Get the default tenant ID
{ getDefaultTenant }
Returns the ID of the default tenant in the system.
Method
/API3/access/getDefaultTenant
- Enterprise Admin
Output Response
Successful Result Code
200
Response Type
string
Description of Response Type
successful operation
Examples
Create new Active Directory user (JavaScript):
This example demonstrates how to find and add a new user and roles in Pyramid, when using Active Directory authentication.
The example uses API authentication driven from JavaScript. See Authentication APIs for alternatives.
// URL of the Pyramid installation and the path to the API 3.0 REST methods
var pyramidURL = "http://mysite.com/api3/";
// step 1: authenticate admin account and get token.
//This assumes authentication with Windows Authentication SSO. Therefore the account logging on is an admin account.
// NOTE: callApi method is a generic REST method shown below. And inside it, xhttp.withCredentials = true;
let token = callApi("authentication/authenticateUserWindows",{},"",false);
log("got token "+token);
//step 2: Get the defult tenant.
let defaultTenantResult = callApi("access/getDefaultTenant",{},
token // admin token generated above
);
let tenantId = defaultTenantResult;
log("default tenant, id= "+tenantId);
//step 3: search for an active directory user in the AD itself
let searchUsers=callApi("access/searchExternalUsers",{
"domainName":"myAdDomain",
"searchValue":"Smith",
"externalSearchType": 0, //search type enumeriation. 0 = exact
},token // admin token generated above
);
let adUser = searchUsers[0];
log("adUser = "+adUser.firstName);
//step 4: creating a user using the results from the search in step 3
let createUser = callApi("access/createUsersFromSearch",[
{
"userName": adUser.username, //using the search result from step 3 above
"adminType": 0, //admin type
"clientLicenseType": 100,//ClientLicenseType.Viewer
"statusID": 1,
"tenantId": tenantId, //tenant Id from above
"domainName":"myAdDomain"
}
],token );
let userId = createUser.modifiedList[0].id;
log("created user "+userId);
//step 5: optional, changing the user from Viewer to Professional
let updateUser=callApi("access/updateUsersFromSearch",[{
"userName": adUser.username,
"adDomainName":"myAdDomain",
"clientLicenseType": 200,//ClientLicenseType.Professional
}],token );
//step 6: creating 2 roles
let createRole=callApi("access/createRoles",[{
"roleName": "role1",
"tenantId": tenantId,
"isGroupRole": false
},{
"roleName": "role2",
"tenantId": tenantId,
"isGroupRole": false
}],token);
let role1 = createRole.modifiedList[0].id;
let role2 = createRole.modifiedList[1].id;
log("created roles "+role1+","+role2);
//step 7: binding user to role1 from step 6
let addUserToRole=callApi("access/addUserToRole",{
"userId":userId,
"roleId":role1
},token );
//step 8: searchAdGroupsForUser, searching for AD groups of the given user in the given domain
let groups=callApi("access/searchUserGroups",{
"domainName":"myAdDomain",
"username":adUser.username
},token );
log("groups of " + adUser.username+" + "+JSON.stringify(groups));
let selectedGroup=groups[0];
//step 9: add role2 to the AD security group from step 8
let addRoleToAdGroup=callApi("access/updateRoleGroups",{
roleId:"role2",
"groupsToAdd":[{
"domainName":selectedGroup.domainAddress,
"groupName":selectedGroup.name
}]
},token );
log("addRoleToAdGroup "+JSON.stringify(addRoleToAdGroup));
//step 10: optional get all groups by role - this will find the selected Group from step 9
let groupsFound=callApi("access/getRoleGroups",role2,token );
log("found group "+groupsFound[0].name);
// ##### optional generic logging method for debugging ##############
function log(msg){
document.write(msg);
console.log(msg);
}
// ##### generic REST API calling method ##############
function callApi(path,data,token="",parseResult=true){
var xhttp = new XMLHttpRequest();
//notice we changed callApi and added xhttp.withCredentials = true; to pass the windows credentials
xhttp.withCredentials = true;
xhttp.open("POST", pyramidURL+path, false);
xhttp.setRequestHeader("paToken",token)
xhttp.send(JSON.stringify(data));
if(parseResult){
return JSON.parse(xhttp.responseText);
}else{
return xhttp.responseText;
}
}
Content Operations (JavaScript):
This example demonstrates how to manage content items in Pyramid.
The example uses API authentication driven from JavaScript. See Authentication APIs for alternatives.
// URL of the Pyramid installation and the path to the API 3.0 REST methods
var pyramidURL = "http://mySite.com/api3/";
// step 1: authenticate admin account and get token
// NOTE: callApi method is a generic REST method shown below.
let token = callApi("authentication/authenticateUser",{
"userName":"adminUser",
"password":"abc123!"
},"",false);
log("got token "+token);
//step 2: get the default tenant ID
let defaultTenant=callApi("access/getDefaultTenant",{
},token // admin token generated above
);
//step 3: return the ID of the public root folder for the tenant from step 2
let tenentPublicFolder = callApi("content/getTenantPublicOrGroupFolder",{
"validRootFolderType": 1,//the public folder of the default tenant
"tenantId": defaultTenant
},token // admin token generated from step 1 above
);
//step 4: add a new folder to the public folder from step 3
let folderCreation = callApi("content/createNewFolder",{
"parentFolderId": tenentPublicFolder.id,
"folderName": "new folder"
},token);
let folderId=folderCreation.modifiedList[0].id;
//step 5: find roles
let findRole = callApi("access/findRoles",{
"searchValue": "role1",
"searchMatchType": 2//SearchMatchType.Equals
},token);
let roleId=findRole[0].roleId;
log("found role with id= "+ roleId);
//step 6:add the role we found in step 5 to the folder we created (folderId) in step 4
let addRoleToFolder= callApi("content/addRoleToItem",{
"itemId": folderId,
"roleId": roleId//SearchMatchType.Equals
},token);
//step 7: read in a Pyramid Import/Export ('PIE') file
let file="http://myOtherSite.com/Sample.pie";
let pieFile=readPieFile(file);
//step 8: import the PIT file into the folder from step 4
let importContent = callApi("content/importContent",{
"rootFolderId": folderId, //from step 4
"fileZippedData": pieFile, //the file's content from step 7
"clashDefaultOption":1,//ClashDefaultOption.REPLACE_FILE like default
"rolesAssignmentType":3//RoleAssignmentType.ForceParentFolderRoles take roles from parent folder
},token);
let itemId=Object.keys(importContent.importDscMap)[0];
//step 9: optional, search for the item we just imported, it's id is itemId
let findContentItem = callApi("content/findContentItem",{
"searchString":"import",
"filterTypes":[3],//ContentTypeObject.DataDiscoveryv
"searchMatchType":2,//SearchMatchType.Equals
"searchRootFolderType":1//SearchRootFolderType.Public
},token);
//step 10: check if you need to run datasource changer
// (since the datasource that created this report dosen't exists on this server)
if(importContent.importDscMap[itemId][0].needsToPerformDsc){
// step 10A: get item's data source connection
let correntConnectionStringId=importContent.importDscMap[itemId][0].connectionStringProperties.id
//step 10B: run the data source changer on the items
let changedDatasource = callApi("dataSources/changeDataSource",{
"fromConnId":correntConnectionStringId,
"toConnId":"55ff277a-53ff-4c39-8f15-5651f1026a2d",//retrive this id using 'getAllConnectionStrings'
"itemId":itemId
},token);
}
//step 11: copying the imported item to the tenant root folder
let copyItems = callApi("content/copyItems",{
"itemsForMove":[itemId],
"destinationFolder":tenentPublicFolder.id
},token);
//step 12: remove roles from the folder but not from the item
let removeRoleFromCreatedFolder= callApi("content/removeRolesFromItem",{
"itemId": folderId,
"roleIds": [roleId]
},token);
//step 13: hard delete the folder (permanently)
let folderDeletion = callApi("content/purgeContentItems",[
folderCreation.modifiedList[0].id
],token);
//step 14: soft-delete the items
let itemSoftDeletion = callApi("content/deleteItems",[
copyItems.modifiedList[0].id
],token);
function log(msg){
document.write(msg);
console.log(msg);
}
// ##### generic REST API calling method ##############
function callApi(path,data,token="",parseResult=true){
var xhttp = new XMLHttpRequest();
xhttp.open("POST", pyramidURL+path, false);
xhttp.setRequestHeader("paToken",token)
xhttp.send(JSON.stringify(data));
if(parseResult){
return JSON.parse(xhttp.responseText);
}else{
return xhttp.responseText;
}
}
//example function to read in the contents of a 'PIE' file that contains
//exported Pyramid content.
function readPieFile(file){
var rawFile = new XMLHttpRequest();
rawFile.open("GET", file, false);
rawFile.send(null);
rawFile.onreadystatechange = function () {
if (request.readyState === 4 && request.status === 200) {
return request.responseText;
}
}
}
Code Snippets
Use the Authentication API methods to generate an access 'key' or 'token' for use in code as shown below.
TypeScript
Curl
Java
C#
Python
PHP
curl -X POST \
-H "paToken: [[apiKey]]" \
-H "Accept: application/json,application/json;charset=utf-8,text/plain,text/plain;charset=utf-8" \
"http://Your.Server.URL/API3/access/getDefaultTenant"
import com.pyramidanalytics.*;
import com.pyramidanalytics.auth.*;
import com.pyramidanalytics.model.*;
import com.pyramidanalytics.api.AccessServiceApi;
import java.util.*;
import java.time.*;
public class AccessServiceApiExample {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://Your.Server.URL/");
// Configure API key authorization: paToken
ApiKeyAuth paToken = (ApiKeyAuth) defaultClient.getAuthentication("paToken");
paToken.setApiKey("YOUR API KEY");
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//paToken.setApiKeyPrefix("Token");
// Create an instance of the API class
AccessServiceApi apiInstance = new AccessServiceApi();
try {
String result = apiInstance.getDefaultTenant();
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling AccessServiceApi#getDefaultTenant");
e.printStackTrace();
}
}
}
import * as PyramidAnalyticsWebApi from "com.pyramidanalytics";
// Create an instance of the API class
const api = new PyramidAnalyticsWebApi.AccessServiceApi("http://Your.Server.URL")
api.getDefaultTenant().then(function(data) {
console.log('API called successfully. Returned data: ' + data);
}, function(error) {
console.error(error);
});
using System;
using System.Diagnostics;
using PyramidAnalytics.Sdk.Api;
using PyramidAnalytics.Sdk.Client;
using PyramidAnalytics.Sdk.Model;
public class getDefaultTenantExample
{
public static void Main()
{
Configuration conf = new Configuration();
conf.BasePath = "http://Your.Server.URL/";
// Configure API key authorization: paToken
conf.ApiKey.Add("paToken", "YOUR_API_KEY");
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// conf.ApiKeyPrefix.Add("paToken", "Bearer");
GlobalConfiguration.Instance = conf;
// Create an instance of the API class
var apiInstance = new AccessServiceApi();
try {
// Returns the ID of the default tenant in the system.
string result = apiInstance.getDefaultTenant();
Debug.WriteLine(result);
} catch (Exception e) {
Debug.Print("Exception when calling AccessServiceApi.getDefaultTenant: " + e.Message );
}
}
}
import com.pyramidanalytics
from com.pyramidanalytics import ApiException
from com.pyramidanalytics import AccessServiceApi
from pprint import pprint
# Configure API key authorization: paToken
api_config = com.pyramidanalytics.Configuration(host = 'http://Your.Server.URL/', api_key={ paToken:'YOUR_ACCESS_TOKEN' })
with com.pyramidanalytics.ApiClient(api_config) as api_client:
# Create an instance of the API class
api_instance = AccessServiceApi(api_client)
try:
# Returns the ID of the default tenant in the system.
api_response = api_instance.get_default_tenant()
pprint(api_response)
except ApiException as e:
print("Exception when calling AccessServiceApi->getDefaultTenant: %s\n" % e)
<?php
require_once(__DIR__ . '/vendor/autoload.php');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setHost('http://Your.Server.URL');
// Configure API key authorization: paToken
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('paToken', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('paToken', 'Bearer');
// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccessServiceApi();
try {
$result = $api_instance->getDefaultTenant();
print_r($result);
} catch (Exception $e) {
echo 'Exception when calling AccessServiceApi->getDefaultTenant: ', $e->getMessage(), PHP_EOL;
}
?>