How to Integrate Replit with Tableau

1// verify-tableau-secrets.js
2const required = ['TABLEAU_SERVER_URL', 'TABLEAU_SITE_ID', 'TABLEAU_PAT_NAME', 'TABLEAU_PAT_SECRET'];
3const missing = required.filter(k => !process.env[k]);
4if (missing.length) {
5  console.error('Missing secrets:', missing.join(', '));
6  console.error('Add them in Replit Secrets (lock icon 🔒).');
7  process.exit(1);
8}
9console.log('All Tableau secrets configured.');
10console.log('Server:', process.env.TABLEAU_SERVER_URL);
11console.log('Site ID:', process.env.TABLEAU_SITE_ID || '(default site)');
12console.log('PAT name:', process.env.TABLEAU_PAT_NAME);

1# tableau_client.py — Tableau REST API client with PAT auth (Python)
2import os
3import time
4import requests
5
6TABLEAU_SERVER = os.environ['TABLEAU_SERVER_URL']
7TABLEAU_SITE_ID = os.environ['TABLEAU_SITE_ID']  # empty string for default site
8PAT_NAME = os.environ['TABLEAU_PAT_NAME']
9PAT_SECRET = os.environ['TABLEAU_PAT_SECRET']
10API_VERSION = '3.18'  # Update to match your Tableau Server version
11
12class TableauClient:
13    def __init__(self):
14        self.token = None
15        self.site_luid = None
16        self.token_expiry = 0
17        self.base_url = f"{TABLEAU_SERVER}/api/{API_VERSION}"
18
19    def _sign_in(self):
20        resp = requests.post(
21            f"{self.base_url}/auth/signin",
22            json={
23                'credentials': {
24                    'personalAccessTokenName': PAT_NAME,
25                    'personalAccessTokenSecret': PAT_SECRET,
26                    'site': {'contentUrl': TABLEAU_SITE_ID}
27                }
28            }
29        )
30        resp.raise_for_status()
31        creds = resp.json()['credentials']
32        self.token = creds['token']
33        self.site_luid = creds['site']['id']
34        self.token_expiry = time.time() + 7000  # ~2 hours
35        print(f'Signed in to Tableau. Site LUID: {self.site_luid}')
36
37    def _ensure_auth(self):
38        if not self.token or time.time() > self.token_expiry:
39            self._sign_in()
40
41    def get(self, path, params=None):
42        self._ensure_auth()
43        url = f"{self.base_url}/sites/{self.site_luid}{path}"
44        resp = requests.get(url, headers={'x-tableau-auth': self.token}, params=params)
45        resp.raise_for_status()
46        return resp.json()
47
48    def post(self, path, body=None):
49        self._ensure_auth()
50        url = f"{self.base_url}/sites/{self.site_luid}{path}"
51        resp = requests.post(url, headers={'x-tableau-auth': self.token}, json=body)
52        resp.raise_for_status()
53        return resp.json()
54
55    def sign_out(self):
56        if self.token:
57            requests.post(
58                f"{self.base_url}/auth/signout",
59                headers={'x-tableau-auth': self.token}
60            )
61            self.token = None
62
63# Usage
64if __name__ == '__main__':
65    client = TableauClient()
66    workbooks = client.get('/workbooks')
67    for wb in workbooks.get('workbooks', {}).get('workbook', []):
68        print(f"  [{wb['id']}] {wb['name']} — {wb['project']['name']}")

1// tableau-views.js — Query workbooks and download view images (Node.js)
2const axios = require('axios');
3const fs = require('fs');
4
5const SERVER = process.env.TABLEAU_SERVER_URL;
6const SITE_ID = process.env.TABLEAU_SITE_ID;
7const PAT_NAME = process.env.TABLEAU_PAT_NAME;
8const PAT_SECRET = process.env.TABLEAU_PAT_SECRET;
9const API_VERSION = '3.18';
10
11let sessionToken = null;
12let siteLuid = null;
13
14async function signIn() {
15  const resp = await axios.post(`${SERVER}/api/${API_VERSION}/auth/signin`, {
16    credentials: {
17      personalAccessTokenName: PAT_NAME,
18      personalAccessTokenSecret: PAT_SECRET,
19      site: { contentUrl: SITE_ID }
20    }
21  });
22  sessionToken = resp.data.credentials.token;
23  siteLuid = resp.data.credentials.site.id;
24  console.log('Signed in. Site LUID:', siteLuid);
25}
26
27function authHeaders() {
28  return { 'x-tableau-auth': sessionToken };
29}
30
31async function listWorkbooks() {
32  const resp = await axios.get(
33    `${SERVER}/api/${API_VERSION}/sites/${siteLuid}/workbooks`,
34    { headers: authHeaders() }
35  );
36  return resp.data.workbooks.workbook || [];
37}
38
39async function getWorkbookViews(workbookLuid) {
40  const resp = await axios.get(
41    `${SERVER}/api/${API_VERSION}/sites/${siteLuid}/workbooks/${workbookLuid}/views`,
42    { headers: authHeaders() }
43  );
44  return resp.data.views.view || [];
45}
46
47async function downloadViewImage(viewLuid, outputPath) {
48  const resp = await axios.get(
49    `${SERVER}/api/${API_VERSION}/sites/${siteLuid}/views/${viewLuid}/image`,
50    {
51      headers: authHeaders(),
52      responseType: 'arraybuffer',
53      params: { maxAge: 0 }  // Force fresh render
54    }
55  );
56  fs.writeFileSync(outputPath, resp.data);
57  console.log(`View image saved to ${outputPath} (${resp.data.byteLength} bytes)`);
58}
59
60async function downloadViewPdf(viewLuid, outputPath) {
61  const resp = await axios.get(
62    `${SERVER}/api/${API_VERSION}/sites/${siteLuid}/views/${viewLuid}/pdf`,
63    {
64      headers: authHeaders(),
65      responseType: 'arraybuffer',
66      params: { orientation: 'Landscape', type: 'A4' }
67    }
68  );
69  fs.writeFileSync(outputPath, resp.data);
70  console.log(`PDF saved to ${outputPath}`);
71}
72
73async function main() {
74  await signIn();
75  const workbooks = await listWorkbooks();
76  console.log(`\nFound ${workbooks.length} workbook(s)`);
77
78  if (workbooks.length > 0) {
79    const wb = workbooks[0];
80    console.log(`\nViews in "${wb.name}":`);
81    const views = await getWorkbookViews(wb.id);
82    views.forEach(v => console.log(`  [${v.id}] ${v.name}`));
83
84    if (views.length > 0) {
85      await downloadViewImage(views[0].id, 'dashboard.png');
86      await downloadViewPdf(views[0].id, 'dashboard.pdf');
87    }
88  }
89}
90
91main().catch(console.error);

1# tableau_api.py — Express-style Flask API for Tableau operations
2import os
3import time
4import requests
5from flask import Flask, jsonify, request
6
7TABLEAU_SERVER = os.environ['TABLEAU_SERVER_URL']
8TABLEAU_SITE_ID = os.environ['TABLEAU_SITE_ID']
9PAT_NAME = os.environ['TABLEAU_PAT_NAME']
10PAT_SECRET = os.environ['TABLEAU_PAT_SECRET']
11API_VERSION = '3.18'
12
13app = Flask(__name__)
14
15# Global session state
16_token = None
17_site_luid = None
18_expiry = 0
19
20def ensure_auth():
21    global _token, _site_luid, _expiry
22    if _token and time.time() < _expiry:
23        return
24    resp = requests.post(
25        f'{TABLEAU_SERVER}/api/{API_VERSION}/auth/signin',
26        json={'credentials': {
27            'personalAccessTokenName': PAT_NAME,
28            'personalAccessTokenSecret': PAT_SECRET,
29            'site': {'contentUrl': TABLEAU_SITE_ID}
30        }}
31    )
32    resp.raise_for_status()
33    creds = resp.json()['credentials']
34    _token = creds['token']
35    _site_luid = creds['site']['id']
36    _expiry = time.time() + 7000
37
38def tableau_get(path, **kwargs):
39    ensure_auth()
40    url = f'{TABLEAU_SERVER}/api/{API_VERSION}/sites/{_site_luid}{path}'
41    resp = requests.get(url, headers={'x-tableau-auth': _token}, **kwargs)
42    resp.raise_for_status()
43    return resp
44
45def tableau_post(path, body=None):
46    ensure_auth()
47    url = f'{TABLEAU_SERVER}/api/{API_VERSION}/sites/{_site_luid}{path}'
48    resp = requests.post(url, headers={'x-tableau-auth': _token}, json=body)
49    resp.raise_for_status()
50    return resp.json()
51
52@app.route('/api/tableau/workbooks')
53def list_workbooks():
54    data = tableau_get('/workbooks').json()
55    workbooks = data.get('workbooks', {}).get('workbook', [])
56    return jsonify({'count': len(workbooks), 'workbooks': [
57        {'id': w['id'], 'name': w['name'], 'project': w.get('project', {}).get('name', '')}
58        for w in workbooks
59    ]})
60
61@app.route('/api/tableau/datasources')
62def list_datasources():
63    data = tableau_get('/datasources').json()
64    datasources = data.get('datasources', {}).get('datasource', [])
65    return jsonify({'datasources': [
66        {'id': ds['id'], 'name': ds['name']}
67        for ds in datasources
68    ]})
69
70@app.route('/api/tableau/datasources/<ds_luid>/refresh', methods=['POST'])
71def refresh_datasource(ds_luid):
72    result = tableau_post(f'/datasources/{ds_luid}/refresh')
73    job_id = result.get('job', {}).get('id', 'unknown')
74    return jsonify({'status': 'refresh_triggered', 'job_id': job_id})
75
76if __name__ == '__main__':
77    app.run(host='0.0.0.0', port=3000)