Swift Embed SDK for iOS apps

dependencies: [
    .package(url: "https://github.com/thoughtspot/swift-embed-sdk.git", from: "x.y.z")
]

import SwiftUI
import SwiftEmbedSDK
import Combine

 let staticEmbedConfig = EmbedConfig(
    thoughtSpotHost: "https://your-thoughtspot-instance.com", // Replace with actual host URL
    authType: AuthType.TrustedAuthTokenCookieless,
    customizations: customizationsObject // For optional customizations
 )

func fetchAuthToken(username: String, secretKey: String, host: String) async -> String? {
    let urlString = "\(host)/api/rest/2.0/auth/token/full"
    guard let url = URL(string: urlString) else {
        print("Error: Invalid URL: \(urlString)")
        return nil
    }

    let headers: [String: String] = [
        "Accept": "application/json",
        "Content-Type": "application/json"
    ]

    let body: [String: Any] = [
        "username": username,
        "validity_time_in_sec": 30,
        "auto_create": false,
        "secret_key": secretKey
    ]

    do {
        let jsonData = try JSONSerialization.data(withJSONObject: body)

        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.allHTTPHeaderFields = headers
        request.httpBody = jsonData

        let (data, response) = try await URLSession.shared.data(for: request)

        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            // Handle error response
            return nil
        }

        let decodedResponse = try JSONDecoder().decode(AuthTokenResponse.self, from: data)
        return decodedResponse.token

    } catch {
        print("Error fetching auth token: \(error)")
        return nil
    }
}

// Configure the Liveboard view with the desired Liveboard GUID
let liveboardViewConfig = LiveboardViewConfig(
    liveboardId: "your-liveboard-id" // Replace with the actual Liveoard GUID
)

// Create a controller for the embedded Liveboard
let liveboardController = LiveboardEmbedController(
    tsEmbedConfig: tsEmbedConfig,
    viewConfig: liveboardViewConfig
))

import SwiftUI
import SwiftEmbedSDK

struct HomeView: View {

    var username: "user" // ThoughtSpot username for authentication
    var thoughtSpotHost: "https://your-thoughtspot-instance" //Replace with your actual ThoughtSpot application URL
    var liveboardId: "your-liveboard-guid" //Replace with your actual Liveboard GUID
    var secretKey: String  //Secret key used to fetch a trusted auth token

    @StateObject var liveboardController: LiveboardEmbedController

    init(username: String, thoughtSpotHost: String, liveboardId: String, secretKey: String) {
        self.username = username
        self.thoughtSpotHost = thoughtSpotHost
        self.liveboardId = liveboardId
        self.secretKey = secretKey

        // Set up custom styling
        let customizationsObject = createCustomizations()

        // Embed configuration with your ThoughtSpot host and custom styles
        let staticEmbedConfig = EmbedConfig(
            thoughtSpotHost: thoughtSpotHost,
            authType: AuthType.TrustedAuthTokenCookieless,
            customizations: customizationsObject
        )

       // Set up auth token provider
        func getAuthToken() -> Future<String, Error> {
            Future { promise in
                Task {
                    if let token = await fetchAuthToken(username: username, secretKey: secretKey, host: thoughtSpotHost) {
                        promise(.success(token))
                    } else {
                        promise(.failure(NSError(
                            domain: "AuthError", code: 1,
                            userInfo: [NSLocalizedDescriptionKey: "Failed to fetch auth token"]
                        )))
                    }
                }
            }
        }

        // Wrap embed configuration objects
        let tsEmbedConfig = TSEmbedConfig(
            embedConfig: staticEmbedConfig,
            getAuthToken: getAuthToken,
            initializationCompletion: { result in
                // Optional: Handle embed init result
            }
        )

        // Optional: Customize menu actions
        // Show only these menu actions in the embedded UI
        let visibleActions = [
            Action.AddFilter,Action.Share,Action.DrillDown, Action.AxisMenuFilter,Action.AxisMenuTimeBucket
        ]

        // Show these actions as disabled (unclickable)
        let disabledActions = ["drillDown", "edit"]

        // Tooltip for disabled actions
        let disabledActionReason = "Contact your administrator to enable this feature"

        let liveboardViewConfig = LiveboardViewConfig(
            liveboardId: liveboardId,
            visibleActions: visibleActions,
            disabledActions: disabledActions,
            disabledActionReason: disabledActionReason
        )

        _liveboardController = StateObject(wrappedValue: LiveboardEmbedController(
            tsEmbedConfig: tsEmbedConfig,
            viewConfig: liveboardViewConfig
        ))
    }

    var body: some View {
        VStack {
            LiveboardEmbed(controller: liveboardController)
                .frame(height: 600)
                .cornerRadius(12)
                .onAppear {
                    registerSDKListeners()
                }

            HStack {
                Button {
                    // Trigger Liveboard reload
                    liveboardController.trigger(event: HostEvent.Reload)
                } label: {
                    Label("Reload", systemImage: "arrow.clockwise")
                }

                Button {
                    //Open the Share dialog
                    liveboardController.trigger(event: HostEvent.Share)
                } label: {
                    Label("Share", systemImage: "square.and.arrow.up")
                }

            }
        }
        .padding()
    }

    // Register listeners for ThoughtSpot embed events
    func registerSDKListeners() {
        // Emit when authentication is initialized
        liveboardController.on(event: EmbedEvent.AuthInit) { _ in
            print("Authentication initialized")
        }
       // Emit when Liveboard is rendered
        liveboardController.on(event: EmbedEvent.LiveboardRendered) { _ in
            print("Liveboard rendered")
        }
       // Event listener for error events
        liveboardController.on(event: EmbedEvent.Error) { _ in
            print("Error occurred")
        }
    }

    // Customize styles with CSS variables
    func createCustomizations() -> Customizations {
        let cssVariablesDict: [String: String] = [
            "--ts-var-root-background": "#fef4dd",
            "--ts-var-root-color": "#4a4a4a",
            "--ts-var-viz-title-color": "#8e6b23",
            "--ts-var-viz-title-font-family": "'Georgia', 'Times New Roman', serif",
            "--ts-var-viz-title-text-transform": "capitalize",
            "--ts-var-viz-description-color": "#6b705c",
            "--ts-var-viz-description-font-family": "'Verdana', 'Helvetica', sans-serif",
            "--ts-var-viz-border-radius": "6px",
            "--ts-var-viz-box-shadow": "0 3px 6px rgba(0, 0, 0, 0.15)",
            "--ts-var-viz-background": "#fffbf0",
            "--ts-var-viz-legend-hover-background": "#ffe4b5"
        ]
        let customCSS = CustomCss(variables: cssVariablesDict)
        let styleObject = CustomStyles(customCSS: customCSS)

        return Customizations(style: styleObject)
    }
}