ユーザー同期は、Yellowfinをサードパーティ製アプリケーションや統合環境に統合する上で重要なポイントです。ユーザー同期とは、外部のシステムに合わせてYellowfinでユーザーを作成または更新するプロセスです。ユーザーの履歴と設定を保存し、コンテンツを利用するときに適切なセキュリティを適用するには、Yellowfin内でユーザーを作成する必要があります。Yellowfinには、ユーザーを管理し、外部システムとユーザーの更新を同期するためのREST サービスが含まれています。
ユーザー管理に関連するRESTサービスはこちらから利用できます。
ユーザー同期には、主に2つの方法があり、その違いはユーザー同期が行われるタイミングに関係しています。
- 既存のユーザー同期プロセスとのリンク
この方法では、外部システムでユーザーを作成すると同時にユーザーを作成します。つまり、ユーザーが初めてYellowfinにログインしようとする前にユーザーが作成されます。外部システムのユーザーに対する更新も、サービスを通して即座にYellowfinに伝わります。 - オンデマンド (または遅延) 同期
オンデマンド方法では、Yellowfinに初めてログインしようとしているユーザーのみが作成されます。これは、SSOログインプロセスを組み合わせて行うことができます。一般的なパターンは、ユーザーが最初にログインしようとしたときに、SSOコードに以下の処理を実行させることです。- Yellowfinにログインしようとしているユーザーが存在するかどうかを確認します。
- Yellowfinにユーザーが存在しない場合はユーザーを作成します。
- Yellowfinにユーザーが存在する場合は、詳細が変更された場合にユーザーを更新します。
- ユーザーが正しいセキュリティアクセス権を持っているかを確認します。
- ユーザーアクセスが外部システムと異なる場合、ユーザーのグループメンバーシップが正しくなるように調整します。
- SSOを実行し、ユーザーをYellowfinに誘導します。
オンデマンド同期の問題の1つは、グループメンバーシップがユーザーのログイン時にのみ更新されることです。ユーザーがグループメンバーシップ経由でブロードキャストを受信している場合、外部システムでグループから削除された後も、Yellowfinにログインするまでブロードキャストを受信し続ける可能性があります。ただし、システム管理者は、Yellowfin内でグループからユーザーを手動で削除できます。
REST サービスを使用してユーザーを作成および管理する場合、ユーザーJSONモデルを提供する必要があります。こちらは、ユーザーJSONモデルのフォーマットです。
{
"userId": "user1",
"emailAddress": "user1@yellowfin.com.au",
"roleCode": "Consumer & Collaborator",
"password": "secr3t",
"firstName": "User",
"lastName": "One",
"languageCode": "EN",
"timeZoneCode": "AUSTRALIA/SYDNEY",
}
ユーザーを編集または作成する場合、必要な属性をモデルに入力します。ユーザーには、姓、名、ユーザー名、電子メールアドレスのほか、言語とタイムゾーンの設定を指定できます。
ユーザーには、アプリケーション内の様々な機能へのアクセスを決定するロールも割り当てられます。利用可能なロールは、別のAPI 呼び出しを介してリクエストできます。
ユーザーの取得
アプリケーションから既存のユーザーの詳細を取得します。これは、ユーザーが既に存在するかどうかを確認するためにも使用できます。GET /api/rpc/users/user-details-by-username/{user-name} Get a User by Username を照会して、ユーザーの詳細を取得します。
以下の例は、様々なプログラミング言語で、(ユーザー名を使用して) 既存のユーザーを取得する方法を示しています。
Java Expand source
package rest.code.examples;
import java.io.IOException;
import java.util.Random;
import org.apache.hc.client5.http.fluent.Content;
import org.apache.hc.client5.http.fluent.Request;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
/**
* Retrieve a user using the Yellowfin REST API
*/
public class RetrieveAUser {
public static void main(String[] args) throws Exception {
String host = "http://localhost:8080/yellowfinHead";
String restUsername = "admin@yellowfin.com.au";
String restPassword = "test";
String userToRetrieve = "admin@yellowfin.com.au";
String token = generateToken(host, restUsername, restPassword);
System.out.println("Retrieving User: " + userToRetrieve);
Content c = Request.get(host + "/api/rpc/users/user-details-by-username/" + userToRetrieve)
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong() + ", token=" + token)
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.execute().returnContent();
System.out.print(c.asString());
}
public static String generateToken(String host, String username, String password) throws IOException {
Content c = Request.post(host + "/api/refresh-tokens")
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong())
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.bodyString("{ \"userName\": \"+ username + "\",\"password\": \"+ password + "\"}", null)
.execute().returnContent();
JsonObject jsonObject = new JsonParser().parse(c.asString()).getAsJsonObject();
JsonElement accessToken = jsonObject.getAsJsonObject("_embedded").getAsJsonObject("accessToken").get("securityToken");
if (accessToken!=null) {
System.out.println("Access Token: " + accessToken);
} else {
System.out.println("Token not retrieved successfully");
System.exit(-1);
}
return accessToken.getAsString();
}
}
C# Expand source
namespace YellowfinAPIExamples;
using System.Net.Http.Headers;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
public class RetrieveAUser
{
static async Task Main(string[] args)
{
string host = "http://localhost:8080/yellowfinHead";
string restUsername = "admin@yellowfin.com.au";
string restPassword = "test";
string userToRetrieve = "admin@yellowfin.com.au";
string token = await GenerateToken(host, restUsername, restPassword);
Console.WriteLine("Retrieving User: " + userToRetrieve);
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("YELLOWFIN", "ts=" + DateTimeOffset.Now.ToUnixTimeMilliseconds() + " , nonce=" + new Random().NextInt64() + ", token=" + token);
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.yellowfin.api-v1+json"));
HttpResponseMessage response = await httpClient.GetAsync(host + "/api/rpc/users/user-details-by-username/" + userToRetrieve);
if (response.IsSuccessStatusCode)
{
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
else
{
Console.WriteLine("Failed to retrieve user details. Status code: " + response.StatusCode);
}
}
}
static async Task<string> GenerateToken(string host, string restUsername, string restPassword)
{
using (var client = new HttpClient())
{
// Generate nonce
long nonce = new Random().NextInt64();
// Create HTTP request
var request = new HttpRequestMessage(HttpMethod.Post, host + "/api/refresh-tokens");
request.Headers.Add("Authorization", "YELLOWFIN ts=" + DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() + ", nonce=" + nonce);
request.Headers.Add("Accept", "application/vnd.yellowfin.api-v1+json");
request.Content = new StringContent(
JsonConvert.SerializeObject(new { userName = restUsername, password = restPassword }),
MediaTypeHeaderValue.Parse("application/json")
);
// Send request and get response
HttpResponseMessage response = await client.SendAsync(request);
string responseContent = await response.Content.ReadAsStringAsync();
// Parse JSON response
JObject jsonObject = JsonConvert.DeserializeObject<JObject>(responseContent);
string accessToken = jsonObject["_embedded"]["accessToken"]["securityToken"].ToString();
if (!string.IsNullOrEmpty(accessToken))
{
Console.WriteLine("Access Token: " + accessToken);
}
else
{
Console.WriteLine("Token not retrieved");
Environment.Exit(-1);
}
return accessToken;
}
}
}
Go Expand source
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"math/rand"
"net/http"
"time"
)
func main() {
host := "http://localhost:8080/Yellowfin"
restUsername := "admin@yellowfin.com.au"
restPassword := "test"
userToRetrieve := "admin@yellowfin.com.au"
token, err := generateToken(host, restUsername, restPassword)
if err != nil {
fmt.Println("Error generating token:", err)
return
}
fmt.Println("Retrieving User:", userToRetrieve)
client := &http.Client{}
req, err := http.NewRequest("GET", host+"/api/rpc/users/user-details-by-username/"+userToRetrieve, nil)
if err != nil {
fmt.Println("Error creating request:", err)
return
}
nonce := rand.Int63()
req.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d, token=%s", time.Now().UnixMilli(), nonce, token))
req.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
req.Header.Set("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error sending request:", err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return
}
fmt.Println(string(body))
}
func generateToken(host, restUsername, restPassword string) (string, error) {
// Generate nonce
nonce := rand.Int63()
// Create request body
requestBody, err := json.Marshal(map[string]string{
"userName": restUsername,
"password": restPassword,
})
if err != nil {
fmt.Println("Error marshaling request body:", err)
return "", err
}
// Create HTTP client
client := &http.Client{}
// Create HTTP request
request, err := http.NewRequest("POST", host+"/api/refresh-tokens", bytes.NewBuffer(requestBody))
if err != nil {
fmt.Println("Error creating request:", err)
return "", err
}
// Add request headers
request.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d", time.Now().UnixMilli(), nonce))
request.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
request.Header.Set("Content-Type", "application/json")
// Send HTTP request
response, err := client.Do(request)
if err != nil {
fmt.Println("Error sending request:", err)
return "", err
}
defer response.Body.Close()
// Read response body
responseBody, err := ioutil.ReadAll(response.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return "", err
}
// Parse JSON response
var jsonResponse map[string]interface{}
err = json.Unmarshal(responseBody, &jsonResponse)
if err != nil {
fmt.Println("Error parsing JSON response:", err)
return "", err
}
// Get access token from response
accessToken, ok := jsonResponse["_embedded"].(map[string]interface{})["accessToken"].(map[string]interface{})["securityToken"].(string)
if !ok {
fmt.Println("Token not retrieved")
return "", fmt.Errorf("Token not retrieved successfully")
}
return accessToken, nil
}
JavaScript Expand source
const fetch = require('node-fetch');
async function main() {
const host = "http://localhost:8080/Yellowfin";
const restUsername = "admin@yellowfin.com.au";
const restPassword = "test";
const userToRetrieve = "admin@yellowfin.com.au";
try {
const token = await generateToken(host, restUsername, restPassword);
console.log("Retrieving User:", userToRetrieve);
const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${nonce}, token=${token}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
const response = await fetch(`${host}/api/rpc/users/user-details-by-username/${userToRetrieve}`, {
method: 'GET',
headers: headers
});
const userResponse = await response.json();
console.log(JSON.stringify(userResponse));
} catch (error) {
console.error("Error:", error.response ? error.response.data : error.message);
}
}
async function generateToken(host, restUsername, restPassword) {
// Generate nonce
const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
// Create request headers
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${nonce}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
// Create request body
const body = JSON.stringify({
userName: restUsername,
password: restPassword
});
try {
// Make POST request
const response = await fetch(`${host}/api/refresh-tokens`, {
method: 'POST',
headers: headers,
body: body
});
// Check if request was successful
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
// Parse JSON response
const jsonResponse = await response.json();
const accessToken = jsonResponse._embedded.accessToken.securityToken;
if (accessToken) {
console.log(`Access Token: ${accessToken}`);
} else {
console.log("Token not retrieved");
}
return accessToken;
} catch (error) {
console.error("Error:", error.message);
}
return null;
}
main();
PHP Expand source
<?php
function main() {
$host = "http://localhost:8080/Yellowfin";
$restUsername = "admin@yellowfin.com.au";
$restPassword = "test";
$userToRetrieve = "admin@yellowfin.com.au";
try {
$token = generateToken($host, $restUsername, $restPassword);
echo "Retrieving User: $userToRetrieve\n";
$nonce = mt_rand();
$headers = [
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce . ', token=' . $token,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
];
$url = "$host/api/rpc/users/user-details-by-username/$userToRetrieve";
$response = httpRequest('GET', $url, $headers);
echo $response . "\n";
} catch (Exception $e) {
echo "Error: " . $e->getMessage() . "\n";
}
}
function generateToken($host, $restUsername, $restPassword) {
// Generate nonce
$nonce = mt_rand();
// Create request body
$requestBody = json_encode(array(
"userName" => $restUsername,
"password" => $restPassword
));
// Create request headers
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
$response = httpRequest('POST', "$host/api/refresh-tokens", $headers, $requestBody);
// Parse JSON response
$jsonResponse = json_decode($response, true);
// Get access token from response
if (isset($jsonResponse["_embedded"]["accessToken"]["securityToken"])) {
$accessToken = $jsonResponse["_embedded"]["accessToken"]["securityToken"];
echo "Access Token: " . $accessToken;
return $accessToken;
} else {
throw new Exception("Token not retrieved successfully");
}
}
function httpRequest($method, $url, $headers, $data = null) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
if ($data !== null) {
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
}
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Error: ' . curl_error($ch));
}
curl_close($ch);
return $response;
}
main()
?>
Python Expand source
import json
import random
import time
import requests
def main():
host = "http://localhost:8080/yellowfinHead"
rest_username = "admin@yellowfin.com.au"
rest_password = "test"
user_to_retrieve = "admin@yellowfin.com.au"
try:
token = generate_token(host, rest_username, rest_password)
print("Retrieving User:", user_to_retrieve)
nonce = str(random.randint(1, 1000000000))
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}, token={token}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
url = f"{host}/api/rpc/users/user-details-by-username/{user_to_retrieve}"
response = requests.get(url, headers=headers)
if response.status_code == 200:
print(response.text)
else:
print("Failed to retrieve user details. Status code:", response.status_code)
except Exception as e:
print("Error:", e)
def generate_token(host, rest_username, rest_password):
nonce = random.randint(0, 2 ** 63 - 1)
# Create request body
request_body = json.dumps({
"userName": rest_username,
"password": rest_password
})
# Create request headers
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
# Send HTTP request
response = requests.post(host + "/api/refresh-tokens", headers=headers, data=request_body)
# Check response status
if response.status_code == 200:
# Parse JSON response
json_response = response.json()
access_token = json_response["_embedded"]["accessToken"]["securityToken"]
print("Access Token:", access_token)
return access_token
else:
raise Exception("Token not retrieved successfully")
if __name__ == "__main__":
main()
ユーザーの作成
POST /api/admin/users Create User Admin にユーザーモデルの配列を指定して、新しいユーザーを作成します。複数のユーザーモデルを渡して、複数のユーザーを同時に作成します。
以下の例では、様々なプログラミング言語で新しいユーザーを作成します。
こちらのJava コードの例では、REST 呼び出しとJSON シリアル化の処理に、Apache HTTP クライアントとGSONを使用しています。
Java Expand source
package rest.code.examples;
import java.io.IOException;
import java.util.Random;
import org.apache.hc.client5.http.fluent.Content;
import org.apache.hc.client5.http.fluent.Request;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
/**
* Create a user using the Yellowfin REST API
*/
public class CreateAUser {
public static void main(String[] args) throws Exception {
String host = "http://localhost:8080/Yellowfin";
String restUsername = "admin@yellowfin.com.au";
String restPassword = "test";
String createUserPayload = "[ {" +
" \"userId\": \"user1\"," +
" \"emailAddress\": \"user1@yellowfin.com.au\"," +
" \"roleCode\": \"Consumer & Collaborator\"," +
" \"password\": \"test\"," +
" \"firstName\": \"User\"," +
" \"lastName\": \"One\"," +
" \"languageCode\": \"EN\"," +
" \"timeZoneCode\": \"AUSTRALIA/SYDNEY\" +
" } ]";
String token = generateToken(host, restUsername, restPassword);
System.out.println("Payload: " + createUserPayload);
Content c = Request.post(host + "/api/admin/users")
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong() + ", token=" + token)
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.bodyString(createUserPayload, null)
.execute().returnContent();
System.out.print(c.asString());
}
public static String generateToken(String host, String username, String password) throws IOException {
Content c = Request.post(host + "/api/refresh-tokens")
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong())
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.bodyString("{ \"userName\": \"+ username + "\",\"password\": \"+ password + "\"}", null)
.execute().returnContent();
JsonObject jsonObject = new JsonParser().parse(c.asString()).getAsJsonObject();
JsonElement accessToken = jsonObject.getAsJsonObject("_embedded").getAsJsonObject("accessToken").get("securityToken");
if (accessToken!=null) {
System.out.println("Access Token: " + accessToken);
} else {
System.out.println("Token not retrieved successfully");
System.exit(-1);
}
return accessToken.getAsString();
}
}
C# Expand source
namespace YellowfinAPIExamples;
using System.Net.Http.Headers;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
public class CreateAUser
{
static async Task Main(string[] args)
{
string host = "http://localhost:8080/Yellowfin";
string restUsername = "admin@yellowfin.com.au";
string restPassword = "test";
string createUserPayload = "[ {" +
" \"userId\": \"user1\"," +
" \"emailAddress\": \"user1@yellowfin.com.au\"," +
" \"roleCode\": \"Consumer & Collaborator\"," +
" \"password\": \"test\"," +
" \"firstName\": \"User\"," +
" \"lastName\": \"One\"," +
" \"languageCode\": \"EN\"," +
" \"timeZoneCode\": \"AUSTRALIA/SYDNEY\" +
" } ]";
string token = await GenerateToken(host, restUsername, restPassword);
Console.WriteLine("Payload: " + createUserPayload);
using (HttpClient client = new HttpClient())
{
long nonce = new Random().NextInt64();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, host + "/api/admin/users");
request.Headers.Add("Authorization", "YELLOWFIN ts=" + DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() + ", nonce=" + nonce + ", token=" + token);
request.Headers.Add("Accept", "application/vnd.yellowfin.api-v1+json");
request.Content = new StringContent(createUserPayload, System.Text.Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.SendAsync(request);
string content = await response.Content.ReadAsStringAsync();
Console.WriteLine(content);
}
}
static async Task<string> GenerateToken(string host, string restUsername, string restPassword)
{
using (var client = new HttpClient())
{
// Generate nonce
long nonce = new Random().NextInt64();
// Create HTTP request
var request = new HttpRequestMessage(HttpMethod.Post, host + "/api/refresh-tokens");
request.Headers.Add("Authorization", "YELLOWFIN ts=" + DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() + ", nonce=" + nonce);
request.Headers.Add("Accept", "application/vnd.yellowfin.api-v1+json");
request.Content = new StringContent(
JsonConvert.SerializeObject(new { userName = restUsername, password = restPassword }),
MediaTypeHeaderValue.Parse("application/json")
);
// Send request and get response
HttpResponseMessage response = await client.SendAsync(request);
string responseContent = await response.Content.ReadAsStringAsync();
// Parse JSON response
JObject jsonObject = JsonConvert.DeserializeObject<JObject>(responseContent);
string accessToken = jsonObject["_embedded"]["accessToken"]["securityToken"].ToString();
if (!string.IsNullOrEmpty(accessToken))
{
Console.WriteLine("Access Token: " + accessToken);
}
else
{
Console.WriteLine("Token not retrieved");
Environment.Exit(-1);
}
return accessToken;
}
}
}
Go Expand source
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"math/rand"
"net/http"
"time"
)
func main() {
host := "http://localhost:8080/Yellowfin"
restUsername := "admin@yellowfin.com.au"
restPassword := "test"
createUserPayload := `[{
"userId": "user1",
"emailAddress": "user1@yellowfin.com.au",
"roleCode": "Consumer & Collaborator",
"password": "test",
"firstName": "User",
"lastName": "One",
"languageCode": "EN",
"timeZoneCode": "AUSTRALIA/SYDNEY"
}]`
token, err := generateToken(host, restUsername, restPassword)
if err != nil {
fmt.Println("Error generating token:", err)
return
}
fmt.Println("Payload:", createUserPayload)
client := &http.Client{}
request, err := http.NewRequest("POST", host+"/api/admin/users", bytes.NewBuffer([]byte(createUserPayload)))
if err != nil {
fmt.Println("Error creating request:", err)
return
}
request.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d, token=%s", time.Now().UnixMilli(), rand.Int63(), token))
request.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
request.Header.Set("Content-Type", "application/json")
response, err := client.Do(request)
if err != nil {
fmt.Println("Error sending request:", err)
return
}
defer response.Body.Close()
body, err := ioutil.ReadAll(response.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return
}
fmt.Println(string(body))
}
func generateToken(host, restUsername, restPassword string) (string, error) {
// Generate nonce
nonce := rand.Int63()
// Create request body
requestBody, err := json.Marshal(map[string]string{
"userName": restUsername,
"password": restPassword,
})
if err != nil {
fmt.Println("Error marshaling request body:", err)
return ", err
}
// Create HTTP client
client := &http.Client{}
// Create HTTP request
request, err := http.NewRequest("POST", host+"/api/refresh-tokens", bytes.NewBuffer(requestBody))
if err != nil {
fmt.Println("Error creating request:", err)
return ", err
}
// Add request headers
request.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d", time.Now().UnixMilli(), nonce))
request.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
request.Header.Set("Content-Type", "application/json")
// Send HTTP request
response, err := client.Do(request)
if err != nil {
fmt.Println("Error sending request:", err)
return ", err
}
defer response.Body.Close()
// Read response body
responseBody, err := ioutil.ReadAll(response.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return ", err
}
// Parse JSON response
var jsonResponse map[string]interface{}
err = json.Unmarshal(responseBody, &jsonResponse)
if err != nil {
fmt.Println("Error parsing JSON response:", err)
return ", err
}
// Get access token from response
accessToken, ok := jsonResponse["_embedded"].(map[string]interface{})["accessToken"].(map[string]interface{})["securityToken"].(string)
if !ok {
fmt.Println("Token not retrieved")
return ", fmt.Errorf("Token not retrieved successfully")
}
return accessToken, nil
}
JavaScript Expand source
const fetch = require("node-fetch");
async function main() {
const host = "http://localhost:8080/Yellowfin";
const restUsername = "admin@yellowfin.com.au";
const restPassword = "test";
const createUserPayload = JSON.stringify([{
userId: "user1",
emailAddress: "user1@yellowfin.com.au",
roleCode: "Consumer & Collaborator",
password: "test",
firstName: "User",
lastName: "One",
languageCode: "EN",
timeZoneCode: "AUSTRALIA/SYDNEY"
}]);
const token = await generateToken(host, restUsername, restPassword);
if (token === null) {
console.error("Failed to retrieve access token");
return;
}
console.log("Payload:", createUserPayload);
const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${nonce}, token=${token}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
try {
const response = await fetch(`${host}/api/admin/users`, {
method: 'POST',
headers: headers,
body: createUserPayload
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const responseBody = await response.text();
console.log(responseBody);
} catch (error) {
console.error("Error:", error.message);
}
}
async function generateToken(host, restUsername, restPassword) {
// Generate nonce
const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
// Create request headers
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${nonce}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
// Create request body
const body = JSON.stringify({
userName: restUsername,
password: restPassword
});
try {
// Make POST request
const response = await fetch(`${host}/api/refresh-tokens`, {
method: 'POST',
headers: headers,
body: body
});
// Check if request was successful
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
// Parse JSON response
const jsonResponse = await response.json();
const accessToken = jsonResponse._embedded.accessToken.securityToken;
if (accessToken) {
console.log(`Access Token: ${accessToken}`);
} else {
console.log("Token not retrieved");
}
return accessToken;
} catch (error) {
console.error("Error:", error.message);
}
return null;
}
main();
PHP Expand source
<?php
function main() {
$host = "http://localhost:8080/Yellowfin";
$restUsername = "admin@yellowfin.com.au";
$restPassword = "test";
$createUserPayload = json_encode(array(
array(
"userId" => "user1",
"emailAddress" => "user1@yellowfin.com.au",
"roleCode" => "Consumer & Collaborator",
"password" => "test",
"firstName" => "User",
"lastName" => "One",
"languageCode" => "EN",
"timeZoneCode" => "AUSTRALIA/SYDNEY"
)
));
try {
$token = generateToken($host, $restUsername, $restPassword);
} catch (Exception $e) {
echo "Error generating token: " . $e->getMessage();
return;
}
echo "Payload: " . $createUserPayload . "\n";
$nonce = mt_rand();
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce . ', token=' . $token,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
try {
$response = httpRequest('POST', "$host/api/admin/users", $headers, $createUserPayload);
echo $response;
} catch (Exception $e) {
echo "Error sending request: " . $e->getMessage();
}
}
function generateToken($host, $restUsername, $restPassword) {
// Generate nonce
$nonce = mt_rand();
// Create request body
$requestBody = json_encode(array(
"userName" => $restUsername,
"password" => $restPassword
));
// Create request headers
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
$response = httpRequest('POST', "$host/api/refresh-tokens", $headers, $requestBody);
// Parse JSON response
$jsonResponse = json_decode($response, true);
// Get access token from response
if (isset($jsonResponse["_embedded"]["accessToken"]["securityToken"])) {
$accessToken = $jsonResponse["_embedded"]["accessToken"]["securityToken"];
echo "Access Token: " . $accessToken;
return $accessToken;
} else {
throw new Exception("Token not retrieved successfully");
}
}
function httpRequest($method, $url, $headers, $data = null) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
if ($data !== null) {
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
}
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Error: ' . curl_error($ch));
}
curl_close($ch);
return $response;
}
main()
?>
Python Expand source
import json
import random
import time
import requests
def main():
host = "http://localhost:8080/Yellowfin"
rest_username = "admin@yellowfin.com.au"
rest_password = "test"
create_user_payload = json.dumps([{
"userId": "user1",
"emailAddress": "user1@yellowfin.com.au",
"roleCode": "Consumer & Collaborator",
"password": "test",
"firstName": "User",
"lastName": "One",
"languageCode": "EN",
"timeZoneCode": "AUSTRALIA/SYDNEY"
}])
try:
token = generate_token(host, rest_username, rest_password)
except Exception as e:
print(f"Error generating token: {e}")
return
print("Payload:", create_user_payload)
nonce = random.randint(0, 2 ** 63 - 1)
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}, token={token}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
try:
response = requests.post(host + "/api/admin/users", headers=headers, data=create_user_payload)
response.raise_for_status()
print(response.text)
except requests.RequestException as e:
print(f"Error sending request: {e}")
def generate_token(host, rest_username, rest_password):
nonce = random.randint(0, 2 ** 63 - 1)
# Create request body
request_body = json.dumps({
"userName": rest_username,
"password": rest_password
})
# Create request headers
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
# Send HTTP request
response = requests.post(host + "/api/refresh-tokens", headers=headers, data=request_body)
# Check response status
if response.status_code == 200:
# Parse JSON response
json_response = response.json()
access_token = json_response["_embedded"]["accessToken"]["securityToken"]
print("Access Token:", access_token)
return access_token
else:
raise Exception("Token not retrieved successfully")
if __name__ == "__main__":
main()
ユーザーの更新
ユーザーの更新では、上記と同じJSON モデルが使用されます。必要な変更を含むモデルは、PATCH /api/admin/users/{userId} Update a User で使用できます。ここでは、{userId} は、GET /api/rpc/users/user-details-by-username/{user-name} で返される整数識別子です。
ユーザーJSONモデルの配列を受け入れることができるユーザー作成エンドポイントと比較して、更新エンドポイントは1つのユーザーJSONモデルのみをサポートします。
以下の例では、様々なプログラミング言語で既存のユーザーを更新します。
こちらのJava コードの例では、REST 呼び出しとJSON シリアル化の処理に、Apache HTTP クライアントとGSONを使用しています。
Java Expand source
package rest.code.examples;
import java.io.IOException;
import java.util.Random;
import org.apache.hc.client5.http.fluent.Content;
import org.apache.hc.client5.http.fluent.Request;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
/**
* Create a user using the Yellowfin REST API
*/
public class UpdateAUser {
public static void main(String[] args) throws Exception {
String host = "http://localhost:8080/yellowfinHead";
String restUsername = "admin@yellowfin.com.au";
String restPassword = "test";
Integer userIp = 13235;
String updateUserPayload =
"{" +
" \"emailAddress\": \"user1@yellowfin.com.au\"," +
" \"roleCode\": \"Consumer & Collaborator\"," +
" \"password\": \"test\"," +
" \"firstName\": \"User\"," +
" \"lastName\": \"Two\"," +
" \"languageCode\": \"EN\"," +
" \"timeZoneCode\": \"AUSTRALIA/SYDNEY\" +
"}";
String token = generateToken(host, restUsername, restPassword);
System.out.println("Payload: " + updateUserPayload);
Content c = Request.patch(host + "/api/admin/users/" + userIp)
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong() + ", token=" + token)
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.bodyString(updateUserPayload, null)
.execute().returnContent();
System.out.print(c.asString());
}
public static String generateToken(String host, String username, String password) throws IOException {
Content c = Request.post(host + "/api/refresh-tokens")
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong())
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.bodyString("{ \"userName\": \"+ username + "\",\"password\": \"+ password + "\"}", null)
.execute().returnContent();
JsonObject jsonObject = new JsonParser().parse(c.asString()).getAsJsonObject();
JsonElement accessToken = jsonObject.getAsJsonObject("_embedded").getAsJsonObject("accessToken").get("securityToken");
if (accessToken!=null) {
System.out.println("Access Token: " + accessToken);
} else {
System.out.println("Token not retrieved successfully");
System.exit(-1);
}
return accessToken.getAsString();
}
}
C# Expand source
namespace YellowfinAPIExamples
{
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
class UpdateAUser
{
static async Task Main(string[] args)
{
string host = "http://localhost:8080/yellowfinHead";
string restUsername = "admin@yellowfin.com.au";
string restPassword = "test";
int userIp = 13235;
string updateUserPayload = JsonConvert.SerializeObject(new
{
emailAddress = "user1@yellowfin.com.au",
roleCode = "Consumer & Collaborator",
password = "test",
firstName = "User",
lastName = "Two",
languageCode = "EN",
timeZoneCode = "AUSTRALIA/SYDNEY"
});
string token = await GenerateToken(host, restUsername, restPassword);
using (var client = new HttpClient())
{
// Generate nonce
long nonce = new Random().NextInt64();
// Create HTTP request
var request = new HttpRequestMessage(HttpMethod.Patch, $"{host}/api/admin/users/{userIp}");
request.Headers.Add("Authorization", $"YELLOWFIN ts={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()} , nonce={nonce}, token={token}");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.yellowfin.api-v1+json"));
request.Content = new StringContent(updateUserPayload, System.Text.Encoding.UTF8, "application/json");
// Send request and get response
HttpResponseMessage response = await client.SendAsync(request);
string responseContent = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseContent);
}
}
public static async Task<string> GenerateToken(string host, string username, string password)
{
using (var client = new HttpClient())
{
// Generate nonce
long nonce = new Random().NextInt64();
// Create HTTP request
var request = new HttpRequestMessage(HttpMethod.Post, $"{host}/api/refresh-tokens");
request.Headers.Add("Authorization", $"YELLOWFIN ts={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()} , nonce={nonce}");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.yellowfin.api-v1+json"));
request.Content = new StringContent(
JsonConvert.SerializeObject(new { userName = username, password = password }),
System.Text.Encoding.UTF8,
"application/json"
);
// Send request and get response
HttpResponseMessage response = await client.SendAsync(request);
string responseContent = await response.Content.ReadAsStringAsync();
// Parse JSON response
JObject jsonObject = JsonConvert.DeserializeObject<JObject>(responseContent);
string accessToken = jsonObject["_embedded"]["accessToken"]["securityToken"].ToString();
if (!string.IsNullOrEmpty(accessToken))
{
Console.WriteLine("Access Token: " + accessToken);
}
else
{
Console.WriteLine("Token not retrieved successfully");
Environment.Exit(-1);
}
return accessToken;
}
}
}
}
Go Expand source
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"math/rand"
"net/http"
"time"
)
func main() {
host := "http://localhost:8080/yellowfinHead"
restUsername := "admin@yellowfin.com.au"
restPassword := "test"
userIp := 13235
updateUserPayload := map[string]string{
"emailAddress": "user1@yellowfin.com.au",
"roleCode": "Consumer & Collaborator",
"password": "test",
"firstName": "User",
"lastName": "Two",
"languageCode": "EN",
"timeZoneCode": "AUSTRALIA/SYDNEY",
}
token, err := generateToken(host, restUsername, restPassword)
if err != nil {
fmt.Println("Error generating token:", err)
return
}
payloadBytes, err := json.Marshal(updateUserPayload)
if err != nil {
fmt.Println("Error marshaling payload:", err)
return
}
nonce := rand.Int63()
client := &http.Client{}
request, err := http.NewRequest("PATCH", fmt.Sprintf("%s/api/admin/users/%d", host, userIp), bytes.NewBuffer(payloadBytes))
if err != nil {
fmt.Println("Error creating request:", err)
return
}
request.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d, token=%s", time.Now().UnixMilli(), nonce, token))
request.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
request.Header.Set("Content-Type", "application/json")
response, err := client.Do(request)
if err != nil {
fmt.Println("Error sending request:", err)
return
}
defer response.Body.Close()
responseBody, err := ioutil.ReadAll(response.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return
}
fmt.Print(string(responseBody))
}
func generateToken(host, username, password string) (string, error) {
requestBody, err := json.Marshal(map[string]string{
"userName": username,
"password": password,
})
if err != nil {
return ", fmt.Errorf("error marshaling request body: %v", err)
}
nonce := rand.Int63()
client := &http.Client{}
request, err := http.NewRequest("POST", fmt.Sprintf("%s/api/refresh-tokens", host), bytes.NewBuffer(requestBody))
if err != nil {
return ", fmt.Errorf("error creating request: %v", err)
}
request.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d", time.Now().UnixMilli(), nonce))
request.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
request.Header.Set("Content-Type", "application/json")
response, err := client.Do(request)
if err != nil {
return ", fmt.Errorf("error sending request: %v", err)
}
defer response.Body.Close()
responseBody, err := ioutil.ReadAll(response.Body)
if err != nil {
return ", fmt.Errorf("error reading response body: %v", err)
}
var jsonResponse map[string]interface{}
err = json.Unmarshal(responseBody, &jsonResponse)
if err != nil {
return ", fmt.Errorf("error parsing JSON response: %v", err)
}
accessToken, ok := jsonResponse["_embedded"].(map[string]interface{})["accessToken"].(map[string]interface{})["securityToken"].(string)
if !ok {
return ", fmt.Errorf("token not retrieved")
}
fmt.Println("Access Token:", accessToken)
return accessToken, nil
}
JavaScript Expand source
const fetch = require('node-fetch');
async function main() {
const host = "http://localhost:8080/yellowfinHead";
const restUsername = "admin@yellowfin.com.au";
const restPassword = "test";
const userIp = 13235;
const updateUserPayload = JSON.stringify({
emailAddress: "user1@yellowfin.com.au",
roleCode: "Consumer & Collaborator",
password: "test",
firstName: "User",
lastName: "Four",
languageCode: "EN",
timeZoneCode: "AUSTRALIA/SYDNEY"
});
const token = await generateToken(host, restUsername, restPassword);
console.log("Payload:", updateUserPayload);
const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${nonce}, token=${token}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
try {
const response = await fetch(`${host}/api/admin/users/${userIp}`, {
method: 'PATCH',
headers: headers,
body: updateUserPayload
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const responseBody = await response.text();
console.log(responseBody);
} catch (error) {
console.error("Error:", error.message);
}
}
async function generateToken(host, username, password) {
const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${nonce}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
const body = JSON.stringify({
userName: username,
password: password
});
try {
const response = await fetch(`${host}/api/refresh-tokens`, {
method: 'POST',
headers: headers,
body: body
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const jsonResponse = await response.json();
const accessToken = jsonResponse._embedded.accessToken.securityToken;
if (accessToken) {
console.log(`Access Token: ${accessToken}`);
return accessToken;
} else {
console.log("Token not retrieved successfully");
process.exit(-1);
}
} catch (error) {
console.error("Error:", error.message);
process.exit(-1);
}
}
main();
PHP Expand source
<?php
function main()
{
$host = "http://localhost:8080/yellowfinHead";
$restUsername = "admin@yellowfin.com.au";
$restPassword = "test";
$userIp = 13235;
$updateUserPayload = json_encode(array(
"emailAddress" => "user1@yellowfin.com.au",
"roleCode" => "Consumer & Collaborator",
"password" => "test",
"firstName" => "User",
"lastName" => "Two",
"languageCode" => "EN",
"timeZoneCode" => "AUSTRALIA/SYDNEY"
));
$token = generateToken($host, $restUsername, $restPassword);
echo "Payload: " . $updateUserPayload . PHP_EOL;
$nonce = mt_rand();
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce . ', token=' . $token,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
$response = httpRequest('PATCH', "$host/api/admin/users/$userIp", $headers, $updateUserPayload);
echo $response . PHP_EOL;
}
function generateToken($host, $username, $password)
{
$nonce = mt_rand();
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
$body = json_encode(array(
"userName" => $username,
"password" => $password
));
$response = httpRequest('POST', "$host/api/refresh-tokens", $headers, $body);
$jsonResponse = json_decode($response, true);
if (isset($jsonResponse["_embedded"]["accessToken"]["securityToken"])) {
$accessToken = $jsonResponse["_embedded"]["accessToken"]["securityToken"];
echo "Access Token: " . $accessToken . PHP_EOL;
return $accessToken;
} else {
echo "Token not retrieved successfully" . PHP_EOL;
exit(-1);
}
}
function httpRequest($method, $url, $headers, $data = null)
{
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
if ($data !== null) {
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
}
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Error: ' . curl_error($ch));
}
curl_close($ch);
return $response;
}
main();
?>
Python Expand source
import json
import random
import time
import requests
def main():
host = "http://localhost:8080/yellowfinHead"
rest_username = "admin@yellowfin.com.au"
rest_password = "test"
user_ip = 13235
update_user_payload = json.dumps({
"emailAddress": "user1@yellowfin.com.au",
"roleCode": "Consumer & Collaborator",
"password": "test",
"firstName": "User",
"lastName": "Seven",
"languageCode": "EN",
"timeZoneCode": "AUSTRALIA/SYDNEY"
})
token = generate_token(host, rest_username, rest_password)
print("Payload:", update_user_payload)
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={random.randint(0, 2**63 - 1)}, token={token}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
response = requests.patch(f"{host}/api/admin/users/{user_ip}", headers=headers, data=update_user_payload)
print(response.text)
def generate_token(host, username, password):
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={random.randint(0, 2**63 - 1)}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
body = json.dumps({
"userName": username,
"password": password
})
response = requests.post(f"{host}/api/refresh-tokens", headers=headers, data=body)
if response.status_code == 200:
json_response = response.json()
access_token = json_response["_embedded"]["accessToken"]["securityToken"]
print("Access Token:", access_token)
return access_token
else:
print("Token not retrieved successfully")
exit(-1)
if __name__ == "__main__":
main()
ユーザーロールの変更
ユーザーのロールは、標準の更新エンドポイントで更新できます。これは、PATCH /api/admin/users/{userId} Update a User を呼び出すときに、ユーザーJSONモデルにroleCodeを設定することで実現できます。
以下の例では、利用可能なロールを取得するためのGET /api/roles エンドポイントを紹介します。こちらのコード例では、ユーザーのロールをGET /api/roles によって返された最初のロールに変更します。
以下の例では、様々なプログラミング言語でユーザーのロールを変更します。
Java Expand source
package rest.code.examples;
import java.io.IOException;
import java.util.Random;
import org.apache.hc.client5.http.fluent.Content;
import org.apache.hc.client5.http.fluent.Request;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
/**
* Create a user using the Yellowfin REST API
*/
public class UpdateUsersRole {
public static void main(String[] args) throws Exception {
String host = "http://localhost:8080/Yellowfin";
String restUsername = "admin@yellowfin.com.au";
String restPassword = "test";
String userToUpdate = "user1@yellowfin.com.au";
String token = generateToken(host, restUsername, restPassword);
String roleCode = retrieveRole(host, token);
Integer userIpId = retrieveUserIpIdForUsername(host, token, userToUpdate);
String updateUserPayload =
"{" +
" \"roleCode\": \" + roleCode + "\" +
"}";
System.out.println("Payload: " + updateUserPayload);
Content c = Request.patch(host + "/api/admin/users/" + userIpId)
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong() + ", token=" + token)
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.bodyString(updateUserPayload, null)
.execute().returnContent();
System.out.print(c.asString());
}
public static Integer retrieveUserIpIdForUsername(String host, String token, String userName) throws IOException {
Content c = Request.get(host + "/api/rpc/users/user-details-by-username/" + userName)
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong()+ ", token=" + token)
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.execute().returnContent();
JsonObject jsonObject = new JsonParser().parse(c.asString()).getAsJsonObject();
JsonElement userIpJsonAttribute = jsonObject.get("userId");
Integer userIpId = userIpJsonAttribute.getAsInt();
return userIpId;
}
/*
* This function returns a list of roles in the Yellowfin instance and returns the first one
* in the list.
*/
public static String retrieveRole(String host, String token) throws IOException {
Content c = Request.get(host + "/api/roles")
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong()+ ", token=" + token)
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.execute().returnContent();
JsonObject jsonObject = new JsonParser().parse(c.asString()).getAsJsonObject();
JsonElement rolesList = jsonObject.get("items");
JsonObject role = rolesList.getAsJsonArray().get(0).getAsJsonObject();
String roleCode = null;
if (role!=null) {
roleCode = role.get("roleCode").getAsString();
System.out.println("RoleCode: " + roleCode);
} else {
System.out.println("Role not retrieved successfully");
System.exit(-1);
}
return roleCode;
}
/*
* This function generates an access token for a user that will grant them access to
* call REST API endpoints.
*/
public static String generateToken(String host, String username, String password) throws IOException {
Content c = Request.post(host + "/api/refresh-tokens")
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong())
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.bodyString("{ \"userName\": \"+ username + "\",\"password\": \"+ password + "\"}", null)
.execute().returnContent();
JsonObject jsonObject = new JsonParser().parse(c.asString()).getAsJsonObject();
JsonElement accessToken = jsonObject.getAsJsonObject("_embedded").getAsJsonObject("accessToken").get("securityToken");
if (accessToken!=null) {
System.out.println("Access Token: " + accessToken);
} else {
System.out.println("Token not retrieved successfully");
System.exit(-1);
}
return accessToken.getAsString();
}
}
C# Expand source
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;
namespace YellowfinAPIExamples
{
public class UpdateUsersRole
{
public static async Task Main(string[] args)
{
string host = "http://localhost:8080/Yellowfin";
string restUsername = "admin@yellowfin.com.au";
string restPassword = "test";
string userToUpdate = "user1@yellowfin.com.au";
string token = await GenerateToken(host, restUsername, restPassword);
string roleCode = await RetrieveRole(host, token);
int userIpId = await RetrieveUserIpIdForUsername(host, token, userToUpdate);
string updateUserPayload = $"{{ \"roleCode\": \"{roleCode}\" }}";
Console.WriteLine("Payload: " + updateUserPayload);
using (var client = new HttpClient())
{
var request = new HttpRequestMessage(HttpMethod.Patch, $"{host}/api/admin/users/{userIpId}");
request.Headers.Add("Authorization", $"YELLOWFIN ts={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}, nonce={new Random().NextInt64()}, token={token}");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.yellowfin.api-v1+json"));
request.Content = new StringContent(updateUserPayload, System.Text.Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.SendAsync(request);
string responseContent = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseContent);
}
}
public static async Task<int> RetrieveUserIpIdForUsername(string host, string token, string userName)
{
using (var client = new HttpClient())
{
var request = new HttpRequestMessage(HttpMethod.Get, $"{host}/api/rpc/users/user-details-by-username/{userName}");
request.Headers.Add("Authorization", $"YELLOWFIN ts={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}, nonce={new Random().NextInt64()}, token={token}");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.yellowfin.api-v1+json"));
HttpResponseMessage response = await client.SendAsync(request);
string responseContent = await response.Content.ReadAsStringAsync();
JObject jsonObject = JObject.Parse(responseContent);
int userIpId = jsonObject["userId"].Value<int>();
return userIpId;
}
}
public static async Task<string> RetrieveRole(string host, string token)
{
using (var client = new HttpClient())
{
var request = new HttpRequestMessage(HttpMethod.Get, $"{host}/api/roles");
request.Headers.Add("Authorization", $"YELLOWFIN ts={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}, nonce={new Random().NextInt64()}, token={token}");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.yellowfin.api-v1+json"));
HttpResponseMessage response = await client.SendAsync(request);
string responseContent = await response.Content.ReadAsStringAsync();
JObject jsonObject = JObject.Parse(responseContent);
JToken rolesList = jsonObject["items"];
string roleCode = rolesList[0]["roleCode"].Value<string>();
Console.WriteLine("RoleCode: " + roleCode);
return roleCode;
}
}
public static async Task<string> GenerateToken(string host, string username, string password)
{
using (var client = new HttpClient())
{
var request = new HttpRequestMessage(HttpMethod.Post, $"{host}/api/refresh-tokens");
request.Headers.Add("Authorization", $"YELLOWFIN ts={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}, nonce={new Random().NextInt64()}");
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.yellowfin.api-v1+json"));
request.Content = new StringContent($"{{ \"userName\": \"{username}\", \"password\": \"{password}\" }}", System.Text.Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.SendAsync(request);
string responseContent = await response.Content.ReadAsStringAsync();
JObject jsonObject = JObject.Parse(responseContent);
string accessToken = jsonObject["_embedded"]["accessToken"]["securityToken"].Value<string>();
if (!string.IsNullOrEmpty(accessToken))
{
Console.WriteLine("Access Token: " + accessToken);
}
else
{
Console.WriteLine("Token not retrieved successfully");
Environment.Exit(-1);
}
return accessToken;
}
}
}
}
Go Expand source
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"math/rand"
"net/http"
"time"
)
func main() {
host := "http://localhost:8080/Yellowfin"
restUsername := "admin@yellowfin.com.au"
restPassword := "test"
userToUpdate := "user1@yellowfin.com.au"
token, err := generateToken(host, restUsername, restPassword)
if err != nil {
fmt.Println("Error generating token:", err)
return
}
roleCode, err := retrieveRole(host, token)
if err != nil {
fmt.Println("Error retrieving role:", err)
return
}
userIpId, err := retrieveUserIpIdForUsername(host, token, userToUpdate)
if err != nil {
fmt.Println("Error retrieving user IP ID:", err)
return
}
updateUserPayload := fmt.Sprintf(`{ "roleCode": "%s" }`, roleCode)
fmt.Println("Payload:", updateUserPayload)
client := &http.Client{}
request, err := http.NewRequest("PATCH", fmt.Sprintf("%s/api/admin/users/%d", host, userIpId), bytes.NewBuffer([]byte(updateUserPayload)))
if err != nil {
fmt.Println("Error creating request:", err)
return
}
request.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d, token=%s", time.Now().UnixMilli(), rand.Int63(), token))
request.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
request.Header.Set("Content-Type", "application/json")
response, err := client.Do(request)
if err != nil {
fmt.Println("Error sending request:", err)
return
}
defer response.Body.Close()
responseBody, err := ioutil.ReadAll(response.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return
}
fmt.Println(string(responseBody))
}
func retrieveUserIpIdForUsername(host, token, userName string) (int, error) {
client := &http.Client{}
request, err := http.NewRequest("GET", fmt.Sprintf("%s/api/rpc/users/user-details-by-username/%s", host, userName), nil)
if err != nil {
return 0, err
}
request.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d, token=%s", time.Now().UnixMilli(), rand.Int63(), token))
request.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
request.Header.Set("Content-Type", "application/json")
response, err := client.Do(request)
if err != nil {
return 0, err
}
defer response.Body.Close()
responseBody, err := ioutil.ReadAll(response.Body)
if err != nil {
return 0, err
}
var jsonResponse map[string]interface{}
err = json.Unmarshal(responseBody, &jsonResponse)
if err != nil {
return 0, err
}
userIpId, ok := jsonResponse["userId"].(float64)
if !ok {
return 0, fmt.Errorf("error parsing userId from response")
}
return int(userIpId), nil
}
func retrieveRole(host, token string) (string, error) {
client := &http.Client{}
request, err := http.NewRequest("GET", fmt.Sprintf("%s/api/roles", host), nil)
if err != nil {
return ", err
}
request.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d, token=%s", time.Now().UnixMilli(), rand.Int63(), token))
request.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
request.Header.Set("Content-Type", "application/json")
response, err := client.Do(request)
if err != nil {
return ", err
}
defer response.Body.Close()
responseBody, err := ioutil.ReadAll(response.Body)
if err != nil {
return ", err
}
var jsonResponse map[string]interface{}
err = json.Unmarshal(responseBody, &jsonResponse)
if err != nil {
return ", err
}
items, ok := jsonResponse["items"].([]interface{})
if !ok || len(items) == 0 {
return ", fmt.Errorf("error parsing roles from response")
}
role, ok := items[0].(map[string]interface{})
if !ok {
return ", fmt.Errorf("error parsing role from response")
}
roleCode, ok := role["roleCode"].(string)
if !ok {
return ", fmt.Errorf("error parsing roleCode from role")
}
fmt.Println("RoleCode:", roleCode)
return roleCode, nil
}
func generateToken(host, username, password string) (string, error) {
nonce := rand.Int63()
requestBody, err := json.Marshal(map[string]string{
"userName": username,
"password": password,
})
if err != nil {
return ", err
}
client := &http.Client{}
request, err := http.NewRequest("POST", fmt.Sprintf("%s/api/refresh-tokens", host), bytes.NewBuffer(requestBody))
if err != nil {
return ", err
}
request.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d", time.Now().UnixMilli(), nonce))
request.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
request.Header.Set("Content-Type", "application/json")
response, err := client.Do(request)
if err != nil {
return ", err
}
defer response.Body.Close()
responseBody, err := ioutil.ReadAll(response.Body)
if err != nil {
return ", err
}
var jsonResponse map[string]interface{}
err = json.Unmarshal(responseBody, &jsonResponse)
if err != nil {
return ", err
}
accessToken, ok := jsonResponse["_embedded"].(map[string]interface{})["accessToken"].(map[string]interface{})["securityToken"].(string)
if !ok {
return ", fmt.Errorf("token not retrieved successfully")
}
fmt.Println("Access Token:", accessToken)
return accessToken, nil
}
JavaScript Expand source
const fetch = require('node-fetch');
async function main() {
const host = "http://localhost:8080/Yellowfin";
const restUsername = "admin@yellowfin.com.au";
const restPassword = "test";
const userToUpdate = "user1@yellowfin.com.au";
const token = await generateToken(host, restUsername, restPassword);
if (!token) {
console.error("Failed to retrieve access token");
return;
}
const roleCode = await retrieveRole(host, token);
if (!roleCode) {
console.error("Failed to retrieve role");
return;
}
const userIpId = await retrieveUserIpIdForUsername(host, token, userToUpdate);
if (!userIpId) {
console.error("Failed to retrieve user IP ID");
return;
}
const updateUserPayload = JSON.stringify({ roleCode: roleCode });
console.log("Payload:", updateUserPayload);
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)}, token=${token}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
try {
const response = await fetch(`${host}/api/admin/users/${userIpId}`, {
method: 'PATCH',
headers: headers,
body: updateUserPayload
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const responseBody = await response.text();
console.log(responseBody);
} catch (error) {
console.error("Error:", error.message);
}
}
async function retrieveUserIpIdForUsername(host, token, userName) {
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)}, token=${token}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
try {
const response = await fetch(`${host}/api/rpc/users/user-details-by-username/${userName}`, {
method: 'GET',
headers: headers
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const responseBody = await response.json();
const userIpId = responseBody.userId;
if (userIpId !== undefined) {
return userIpId;
} else {
console.error("User IP ID not retrieved successfully");
return null;
}
} catch (error) {
console.error("Error:", error.message);
return null;
}
}
async function retrieveRole(host, token) {
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)}, token=${token}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
try {
const response = await fetch(`${host}/api/roles`, {
method: 'GET',
headers: headers
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const responseBody = await response.json();
const rolesList = responseBody.items;
if (rolesList && rolesList.length > 0) {
const roleCode = rolesList[0].roleCode;
console.log("RoleCode:", roleCode);
return roleCode;
} else {
console.error("Role not retrieved successfully");
return null;
}
} catch (error) {
console.error("Error:", error.message);
return null;
}
}
async function generateToken(host, restUsername, restPassword) {
const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${nonce}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
const body = JSON.stringify({
userName: restUsername,
password: restPassword
});
try {
const response = await fetch(`${host}/api/refresh-tokens`, {
method: 'POST',
headers: headers,
body: body
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const jsonResponse = await response.json();
const accessToken = jsonResponse._embedded.accessToken.securityToken;
if (accessToken) {
console.log(`Access Token: ${accessToken}`);
return accessToken;
} else {
console.error("Token not retrieved");
return null;
}
} catch (error) {
console.error("Error:", error.message);
return null;
}
}
main();
PHP Expand source
<?php
function main() {
$host = "http://localhost:8080/Yellowfin";
$restUsername = "admin@yellowfin.com.au";
$restPassword = "test";
$userToUpdate = "user1@yellowfin.com.au";
try {
$token = generateToken($host, $restUsername, $restPassword);
} catch (Exception $e) {
echo "Error generating token: " . $e->getMessage();
return;
}
try {
$roleCode = retrieveRole($host, $token);
} catch (Exception $e) {
echo "Error retrieving role: " . $e->getMessage();
return;
}
try {
$userIpId = retrieveUserIpIdForUsername($host, $token, $userToUpdate);
} catch (Exception $e) {
echo "Error retrieving user IP ID: " . $e->getMessage();
return;
}
$updateUserPayload = json_encode(array("roleCode" => $roleCode));
echo "Payload: " . $updateUserPayload . "\n";
$nonce = mt_rand();
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce . ', token=' . $token,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
try {
$response = httpRequest('PATCH', "$host/api/admin/users/$userIpId", $headers, $updateUserPayload);
echo $response;
} catch (Exception $e) {
echo "Error sending request: " . $e->getMessage();
}
}
function retrieveUserIpIdForUsername($host, $token, $username) {
$nonce = mt_rand();
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce . ', token=' . $token,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
try {
$response = httpRequest('GET', "$host/api/rpc/users/user-details-by-username/$username", $headers);
$jsonResponse = json_decode($response, true);
$userIpId = $jsonResponse["userId"];
return $userIpId;
} catch (Exception $e) {
throw new Exception("Error retrieving user IP ID: " . $e->getMessage());
}
}
function retrieveRole($host, $token) {
$nonce = mt_rand();
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce . ', token=' . $token,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
try {
$response = httpRequest('GET', "$host/api/roles", $headers);
$jsonResponse = json_decode($response, true);
$rolesList = $jsonResponse["items"];
if (!empty($rolesList)) {
$roleCode = $rolesList[0]["roleCode"];
echo "RoleCode: " . $roleCode . "\n";
return $roleCode;
} else {
throw new Exception("Role not retrieved successfully");
}
} catch (Exception $e) {
throw new Exception("Error retrieving role: " . $e->getMessage());
}
}
function generateToken($host, $restUsername, $restPassword) {
$nonce = mt_rand();
$requestBody = json_encode(array(
"userName" => $restUsername,
"password" => $restPassword
));
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
try {
$response = httpRequest('POST', "$host/api/refresh-tokens", $headers, $requestBody);
$jsonResponse = json_decode($response, true);
if (isset($jsonResponse["_embedded"]["accessToken"]["securityToken"])) {
$accessToken = $jsonResponse["_embedded"]["accessToken"]["securityToken"];
echo "Access Token: " . $accessToken . "\n";
return $accessToken;
} else {
throw new Exception("Token not retrieved successfully");
}
} catch (Exception $e) {
throw new Exception("Error generating token: " . $e->getMessage());
}
}
function httpRequest($method, $url, $headers, $data = null) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
if ($data !== null) {
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
}
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Error: ' . curl_error($ch));
}
curl_close($ch);
return $response;
}
main();
?>
Python Expand source
import json
import random
import time
import requests
def main():
host = "http://localhost:8080/Yellowfin"
rest_username = "admin@yellowfin.com.au"
rest_password = "test"
user_to_update = "user1@yellowfin.com.au"
try:
token = generate_token(host, rest_username, rest_password)
except Exception as e:
print(f"Error generating token: {e}")
return
try:
role_code = retrieve_role(host, token)
except Exception as e:
print(f"Error retrieving role: {e}")
return
try:
user_ip_id = retrieve_user_ip_id_for_username(host, token, user_to_update)
except Exception as e:
print(f"Error retrieving user IP ID: {e}")
return
update_user_payload = json.dumps({
"roleCode": role_code
})
print("Payload:", update_user_payload)
nonce = random.randint(0, 2 ** 63 - 1)
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}, token={token}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
try:
response = requests.patch(f"{host}/api/admin/users/{user_ip_id}", headers=headers, data=update_user_payload)
response.raise_for_status()
print(response.text)
except requests.RequestException as e:
print(f"Error sending request: {e}")
def retrieve_user_ip_id_for_username(host, token, username):
nonce = random.randint(0, 2 ** 63 - 1)
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}, token={token}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
try:
response = requests.get(f"{host}/api/rpc/users/user-details-by-username/{username}", headers=headers)
response.raise_for_status()
json_response = response.json()
user_ip_id = json_response["userId"]
return user_ip_id
except requests.RequestException as e:
print(f"Error retrieving user IP ID: {e}")
return None
def retrieve_role(host, token):
nonce = random.randint(0, 2 ** 63 - 1)
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}, token={token}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
try:
response = requests.get(f"{host}/api/roles", headers=headers)
response.raise_for_status()
json_response = response.json()
roles_list = json_response["items"]
if roles_list:
role_code = roles_list[0]["roleCode"]
print("RoleCode:", role_code)
return role_code
else:
print("Role not retrieved successfully")
return None
except requests.RequestException as e:
print(f"Error retrieving role: {e}")
return None
def generate_token(host, rest_username, rest_password):
nonce = random.randint(0, 2 ** 63 - 1)
request_body = json.dumps({
"userName": rest_username,
"password": rest_password
})
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
try:
response = requests.post(f"{host}/api/refresh-tokens", headers=headers, data=request_body)
response.raise_for_status()
json_response = response.json()
access_token = json_response["_embedded"]["accessToken"]["securityToken"]
print("Access Token:", access_token)
return access_token
except requests.RequestException as e:
print(f"Error generating token: {e}")
return None
if __name__ == "__main__":
main()
ユーザーパスワードの変更
通常ユーザーのパスワードを更新できるのはユーザー自身、または十分な権限を持つシステム管理者のみです。パスワードは、PUT /api/admin/users/{userId}/password Update a User's Password を呼び出すことで更新されます。
こちらのREST 呼び出しのペイロードは、パスワード { "password": "test"} を含む単純なJSON エントリーで構成されます。
以下の例では、様々なプログラミング言語で既存のユーザーのパスワードを更新します。
Java Expand source
package rest.code.examples;
import java.io.IOException;
import java.util.Random;
import org.apache.hc.client5.http.fluent.Content;
import org.apache.hc.client5.http.fluent.Request;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
/**
* Create a user using the Yellowfin REST API
*/
public class UpdateUsersPassword {
public static void main(String[] args) throws Exception {
String host = "http://localhost/yellowfinHead";
String restUsername = "admin@yellowfin.com.au";
String restPassword = "test";
String userToUpdate = "user1@yellowfin.com.au";
String newPassword = "test";
String token = generateToken(host, restUsername, restPassword);;
Integer userIpId = retrieveUserIpIdForUsername(host, token, userToUpdate);
String updatePasswordPayload =
"{" +
" \"password\": \" + newPassword + "\" +
"}";
System.out.println("Payload: " + updatePasswordPayload);
Content c = Request.put(host + "/api/admin/users/" + userIpId + "/password")
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong() + ", token=" + token)
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.bodyString(updatePasswordPayload, null)
.execute().returnContent();
System.out.print(c.asString());
}
public static Integer retrieveUserIpIdForUsername(String host, String token, String userName) throws IOException {
Content c = Request.get(host + "/api/rpc/users/user-details-by-username/" + userName)
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong()+ ", token=" + token)
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.execute().returnContent();
JsonObject jsonObject = new JsonParser().parse(c.asString()).getAsJsonObject();
JsonElement userIpJsonAttribute = jsonObject.get("userId");
Integer userIpId = userIpJsonAttribute.getAsInt();
return userIpId;
}
/*
* This function generates an access token for a user that will grant them access to
* call REST API endpoints.
*/
public static String generateToken(String host, String username, String password) throws IOException {
Content c = Request.post(host + "/api/refresh-tokens")
.addHeader("Authorization", "YELLOWFIN ts=" + System.currentTimeMillis() + " , nonce=" + new Random().nextLong())
.addHeader("Accept", "application/vnd.yellowfin.api-v1+json")
.addHeader("Content-Type", "application/json")
.bodyString("{ \"userName\": \"+ username + "\",\"password\": \"+ password + "\"}", null)
.execute().returnContent();
JsonObject jsonObject = new JsonParser().parse(c.asString()).getAsJsonObject();
JsonElement accessToken = jsonObject.getAsJsonObject("_embedded").getAsJsonObject("accessToken").get("securityToken");
if (accessToken!=null) {
System.out.println("Access Token: " + accessToken);
} else {
System.out.println("Token not retrieved successfully");
System.exit(-1);
}
return accessToken.getAsString();
}
}
C# Expand source
namespace YellowfinAPIExamples
{
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
public class UpdateUsersPassword
{
static async Task Main(string[] args)
{
string host = "http://localhost:8080/Yellowfin";
string restUsername = "admin@yellowfin.com.au";
string restPassword = "test";
string userToUpdate = "user1@yellowfin.com.au";
string newPassword = "test";
string token = await GenerateToken(host, restUsername, restPassword);
int userIpId = await RetrieveUserIpIdForUsername(host, token, userToUpdate);
string updatePasswordPayload = JsonConvert.SerializeObject(new { password = newPassword });
Console.WriteLine("Payload: " + updatePasswordPayload);
long nonce = new Random().NextInt64();
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("YELLOWFIN", $"ts={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()} , nonce={nonce}, token={token}");
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.yellowfin.api-v1+json"));
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, $"{host}/api/admin/users/{userIpId}/password")
{
Content = new StringContent(updatePasswordPayload, System.Text.Encoding.UTF8, "application/json")
};
HttpResponseMessage response = await httpClient.SendAsync(request);
if (response.IsSuccessStatusCode)
{
string responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
else
{
Console.WriteLine("Failed to update user password. Status code: " + response.StatusCode);
}
}
}
static async Task<int> RetrieveUserIpIdForUsername(string host, string token, string userName)
{
long nonce = new Random().NextInt64();
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("YELLOWFIN", $"ts={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()} , nonce={nonce}, token={token}");
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.yellowfin.api-v1+json"));
HttpResponseMessage response = await httpClient.GetAsync($"{host}/api/rpc/users/user-details-by-username/{userName}");
if (response.IsSuccessStatusCode)
{
string responseBody = await response.Content.ReadAsStringAsync();
JObject jsonObject = JsonConvert.DeserializeObject<JObject>(responseBody);
int userIpId = jsonObject["userId"].Value<int>();
return userIpId;
}
else
{
throw new Exception("Failed to retrieve user IP ID. Status code: " + response.StatusCode);
}
}
}
static async Task<string> GenerateToken(string host, string restUsername, string restPassword)
{
using (var client = new HttpClient())
{
long nonce = new Random().NextInt64();
var request = new HttpRequestMessage(HttpMethod.Post, $"{host}/api/refresh-tokens");
request.Headers.Add("Authorization", $"YELLOWFIN ts={DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}, nonce={nonce}");
request.Headers.Add("Accept", "application/vnd.yellowfin.api-v1+json");
request.Content = new StringContent(
JsonConvert.SerializeObject(new { userName = restUsername, password = restPassword }),
System.Text.Encoding.UTF8,
"application/json"
);
HttpResponseMessage response = await client.SendAsync(request);
string responseContent = await response.Content.ReadAsStringAsync();
JObject jsonObject = JsonConvert.DeserializeObject<JObject>(responseContent);
string accessToken = jsonObject["_embedded"]["accessToken"]["securityToken"].ToString();
if (!string.IsNullOrEmpty(accessToken))
{
Console.WriteLine("Access Token: " + accessToken);
}
else
{
Console.WriteLine("Token not retrieved");
Environment.Exit(-1);
}
return accessToken;
}
}
}
}
Go Expand source
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"math/rand"
"net/http"
"time"
)
func main() {
host := "http://localhost:8080/Yellowfin"
restUsername := "admin@yellowfin.com.au"
restPassword := "test"
userToUpdate := "user1@yellowfin.com.au"
newPassword := "test"
token, err := generateToken(host, restUsername, restPassword)
if err != nil {
fmt.Println("Error generating token:", err)
return
}
userIpId, err := retrieveUserIpIdForUsername(host, token, userToUpdate)
if err != nil {
fmt.Println("Error retrieving user IP ID:", err)
return
}
updatePasswordPayload := map[string]string{
"password": newPassword,
}
payloadBytes, err := json.Marshal(updatePasswordPayload)
if err != nil {
fmt.Println("Error marshaling payload:", err)
return
}
fmt.Println("Payload:", string(payloadBytes))
nonce := rand.Int63()
client := &http.Client{}
req, err := http.NewRequest("PUT", fmt.Sprintf("%s/api/admin/users/%d/password", host, userIpId), bytes.NewBuffer(payloadBytes))
if err != nil {
fmt.Println("Error creating request:", err)
return
}
req.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d, token=%s", time.Now().UnixMilli(), nonce, token))
req.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
req.Header.Set("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error sending request:", err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return
}
fmt.Println(string(body))
}
func retrieveUserIpIdForUsername(host, token, userName string) (int, error) {
nonce := rand.Int63()
client := &http.Client{}
req, err := http.NewRequest("GET", fmt.Sprintf("%s/api/rpc/users/user-details-by-username/%s", host, userName), nil)
if err != nil {
fmt.Println("Error creating request:", err)
return 0, err
}
req.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d, token=%s", time.Now().UnixMilli(), nonce, token))
req.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
req.Header.Set("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error sending request:", err)
return 0, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return 0, err
}
var jsonResponse map[string]interface{}
if err := json.Unmarshal(body, &jsonResponse); err != nil {
fmt.Println("Error parsing JSON response:", err)
return 0, err
}
userIpId, ok := jsonResponse["userId"].(float64)
if !ok {
return 0, fmt.Errorf("Failed to retrieve user ID")
}
return int(userIpId), nil
}
func generateToken(host, restUsername, restPassword string) (string, error) {
nonce := rand.Int63()
requestBody, err := json.Marshal(map[string]string{
"userName": restUsername,
"password": restPassword,
})
if err != nil {
fmt.Println("Error marshaling request body:", err)
return ", err
}
client := &http.Client{}
request, err := http.NewRequest("POST", host+"/api/refresh-tokens", bytes.NewBuffer(requestBody))
if err != nil {
fmt.Println("Error creating request:", err)
return ", err
}
request.Header.Set("Authorization", fmt.Sprintf("YELLOWFIN ts=%d, nonce=%d", time.Now().UnixMilli(), nonce))
request.Header.Set("Accept", "application/vnd.yellowfin.api-v1+json")
request.Header.Set("Content-Type", "application/json")
response, err := client.Do(request)
if err != nil {
fmt.Println("Error sending request:", err)
return ", err
}
defer response.Body.Close()
responseBody, err := ioutil.ReadAll(response.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return ", err
}
var jsonResponse map[string]interface{}
if err := json.Unmarshal(responseBody, &jsonResponse); err != nil {
fmt.Println("Error parsing JSON response:", err)
return ", err
}
accessToken, ok := jsonResponse["_embedded"].(map[string]interface{})["accessToken"].(map[string]interface{})["securityToken"].(string)
if !ok {
return ", fmt.Errorf("Token not retrieved successfully")
}
fmt.Println("Access Token:", accessToken)
return accessToken, nil
}
JavaScript Expand source
const fetch = require("node-fetch");
async function main() {
const host = "http://localhost:8080/Yellowfin";
const restUsername = "admin@yellowfin.com.au";
const restPassword = "test";
const userToUpdate = "user1@yellowfin.com.au";
const newPassword = "test";
const token = await generateToken(host, restUsername, restPassword);
if (token === null) {
console.error("Failed to retrieve access token");
return;
}
const userIpId = await retrieveUserIpIdForUsername(host, token, userToUpdate);
const updatePasswordPayload = `{"password": "${newPassword}"}`;
console.log("Payload:", updatePasswordPayload);
const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${nonce}, token=${token}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
try {
const response = await fetch(`${host}/api/admin/users/${userIpId}/password`, {
method: 'PUT',
headers: headers,
body: updatePasswordPayload
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const responseBody = await response.text();
console.log(responseBody);
} catch (error) {
console.error("Error:", error.message);
}
}
async function retrieveUserIpIdForUsername(host, token, userName) {
const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${nonce}, token=${token}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
try {
const response = await fetch(`${host}/api/rpc/users/user-details-by-username/${userName}`, {
method: 'GET',
headers: headers
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const jsonResponse = await response.json();
const userIpId = jsonResponse.userId;
return userIpId;
} catch (error) {
console.error("Error:", error.message);
}
return null;
}
async function generateToken(host, restUsername, restPassword) {
const nonce = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
const headers = {
'Authorization': `YELLOWFIN ts=${Date.now()}, nonce=${nonce}`,
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
};
const body = JSON.stringify({
userName: restUsername,
password: restPassword
});
try {
const response = await fetch(`${host}/api/refresh-tokens`, {
method: 'POST',
headers: headers,
body: body
});
if (!response.ok) {
throw new Error(`HTTP error! Status: ${response.status}`);
}
const jsonResponse = await response.json();
const accessToken = jsonResponse._embedded.accessToken.securityToken;
if (accessToken) {
console.log(`Access Token: ${accessToken}`);
} else {
console.log("Token not retrieved");
}
return accessToken;
} catch (error) {
console.error("Error:", error.message);
}
return null;
}
main();
PHP Expand source
<?php
function main() {
$host = "http://localhost:8080/Yellowfin";
$restUsername = "admin@yellowfin.com.au";
$restPassword = "test";
$userToUpdate = "user1@yellowfin.com.au";
$newPassword = "test";
try {
$token = generateToken($host, $restUsername, $restPassword);
} catch (Exception $e) {
echo "Error generating token: " . $e->getMessage();
return;
}
$userIpId = retrieveUserIpIdForUsername($host, $token, $userToUpdate);
$updatePasswordPayload = '{"password": "' . $newPassword . '"}';
echo "Payload: " . $updatePasswordPayload . "\n";
$nonce = mt_rand();
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce . ', token=' . $token,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
try {
$response = httpRequest('PUT', "$host/api/admin/users/$userIpId/password", $headers, $updatePasswordPayload);
echo $response;
} catch (Exception $e) {
echo "Error sending request: " . $e->getMessage();
}
}
function retrieveUserIpIdForUsername($host, $token, $userName) {
$nonce = mt_rand();
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce . ', token=' . $token,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
try {
$response = httpRequest('GET', "$host/api/rpc/users/user-details-by-username/$userName", $headers);
$jsonResponse = json_decode($response, true);
$userIpId = $jsonResponse["userId"];
return $userIpId;
} catch (Exception $e) {
echo "Error: " . $e->getMessage();
}
return null;
}
function generateToken($host, $restUsername, $restPassword) {
// Generate nonce
$nonce = mt_rand();
// Create request body
$requestBody = json_encode(array(
"userName" => $restUsername,
"password" => $restPassword
));
// Create request headers
$headers = array(
'Authorization: YELLOWFIN ts=' . intval(microtime(true) * 1000) . ', nonce=' . $nonce,
'Accept: application/vnd.yellowfin.api-v1+json',
'Content-Type: application/json'
);
$response = httpRequest('POST', "$host/api/refresh-tokens", $headers, $requestBody);
// Parse JSON response
$jsonResponse = json_decode($response, true);
// Get access token from response
if (isset($jsonResponse["_embedded"]["accessToken"]["securityToken"])) {
$accessToken = $jsonResponse["_embedded"]["accessToken"]["securityToken"];
echo "Access Token: " . $accessToken;
return $accessToken;
} else {
throw new Exception("Token not retrieved successfully");
}
}
function httpRequest($method, $url, $headers, $data = null) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
if ($data !== null) {
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
}
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Error: ' . curl_error($ch));
}
curl_close($ch);
return $response;
}
main();
?>
Python Expand source
import json
import random
import time
import requests
def main():
host = "http://localhost:8080/Yellowfin"
rest_username = "admin@yellowfin.com.au"
rest_password = "test"
user_to_update = "user1@yellowfin.com.au"
new_password = "test"
try:
token = generate_token(host, rest_username, rest_password)
except Exception as e:
print(f"Error generating token: {e}")
return
user_ip_id = retrieve_user_ip_id_for_username(host, token, user_to_update)
update_password_payload = '{"password": "' + new_password + '"}'
print("Payload:", update_password_payload)
nonce = random.randint(0, 2 ** 63 - 1)
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}, token={token}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
try:
response = requests.put(f"{host}/api/admin/users/{user_ip_id}/password", headers=headers, data=update_password_payload)
response.raise_for_status()
print(response.text)
except requests.RequestException as e:
print(f"Error sending request: {e}")
def retrieve_user_ip_id_for_username(host, token, user_name):
nonce = random.randint(0, 2 ** 63 - 1)
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}, token={token}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
try:
response = requests.get(f"{host}/api/rpc/users/user-details-by-username/{user_name}", headers=headers)
response.raise_for_status()
json_response = response.json()
user_ip_id = json_response["userId"]
return user_ip_id
except requests.RequestException as e:
print(f"Error: {e}")
return None
def generate_token(host, rest_username, rest_password):
nonce = random.randint(0, 2 ** 63 - 1)
# Create request body
request_body = json.dumps({
"userName": rest_username,
"password": rest_password
})
# Create request headers
headers = {
'Authorization': f'YELLOWFIN ts={int(time.time() * 1000)}, nonce={nonce}',
'Accept': 'application/vnd.yellowfin.api-v1+json',
'Content-Type': 'application/json'
}
# Send HTTP request
try:
response = requests.post(f"{host}/api/refresh-tokens", headers=headers, data=request_body)
response.raise_for_status()
json_response = response.json()
access_token = json_response["_embedded"]["accessToken"]["securityToken"]
print("Access Token:", access_token)
return access_token
except requests.RequestException as e:
raise Exception("Token not retrieved successfully") from e
if __name__ == "__main__":
main()