Documentation Overview

Welcome to the comprehensive documentation for our platform. This guide provides an overview of all available documentation sections to help you navigate to the specific information you need.

Available Documentation Sections

Customer Onboarding & SSO Integration

The onboarding documentation guides you through implementing and customizing the customer onboarding process, which integrates with Azure AD B2C for authentication. Key features include:

• Tenant Configuration Schema: Define onboarding steps, forms, and user flows
• Onboarding Data Structure: Configure user and company information collection
• Webhooks and Notifications: Integrate with external systems during onboarding
• Form Elements and Layout: Build custom form layouts with conditional logic

For detailed SSO implementation, see the SSO Integration Guide, which covers:

• Azure AD B2C Configuration: Complete setup parameters for authentication
• MSAL.js Implementation: Client-side authentication code examples
• Security Best Practices: Recommendations for secure token handling and validation

Notifications API

The Notifications documentation details how to engage with users across multiple communication channels including:

• SMS Notifications: Send text messages to mobile devices
• Email Notifications: Support for direct emails and template-based messaging
• WhatsApp Notifications: Text-only and template message options
• In-App Notifications: Display alerts within your applications

Each notification channel includes API endpoints, request formats, and authentication requirements. For implementation guidance, see best practices for notifications.

Telemetry Standards

The Telemetry documentation outlines standards for implementing consistent monitoring across applications:

• OpenTelemetry Requirements: Framework and implementation standards
• Logging Best Practices: Naming conventions and identifier standards
• Implementation Examples: Code samples across multiple languages
• Performance Considerations: Guidance for efficient telemetry implementation

These standards ensure effective tracking, troubleshooting, and performance analysis across distributed systems.

Website Builder

The Website Builder documentation explains how to rapidly create and deploy branded websites with minimal configuration:

• Configuration Setup: Step-by-step guide for tenant creation and configuration
• Page Management: Define and customize website pages and navigation
• Styling Options: Brand customization through CSS and asset configuration
• Authentication Integration: Connect to identity providers for user management
• Custom Scripts and Events: Extend website functionality with custom code

Additional documentation covers custom domain setup, event handling, and authentication configuration.

Styling Guidelines

The Styling documentation provides design system guidance to ensure visual consistency across applications including:

• Color Palettes: Standardized color schemes for UI elements
• Typography: Font families, sizes, and styles for consistent text display
• Component Styling: Visual guidelines for common UI components
• Responsive Design: Practices for adapting interfaces to different screen sizes

Implementation Code Examples

Throughout the documentation, you'll find code examples in multiple languages:

C#

// Example authentication implementation
public class AuthClient
{
    private readonly IPublicClientApplication _msalApp;
    
    public AuthClient(string clientId, string authority)
    {
        var options = new PublicClientApplicationOptions
        {
            ClientId = clientId,
            Authority = authority
        };
        
        _msalApp = PublicClientApplicationBuilder
            .CreateWithApplicationOptions(options)
            .Build();
    }
    
    public async Task<AuthenticationResult> SignInAsync(string[] scopes)
    {
        try
        {
            var accounts = await _msalApp.GetAccountsAsync();
            var result = await _msalApp.AcquireTokenSilent(scopes, accounts.FirstOrDefault())
                .ExecuteAsync();
            return result;
        }
        catch (MsalUiRequiredException)
        {
            var result = await _msalApp.AcquireTokenInteractive(scopes)
                .ExecuteAsync();
            return result;
        }
    }
}

Java

// Example authentication implementation
public class AuthClient {
    private final IPublicClientApplication msalApp;
    
    public AuthClient(String clientId, String authority) {
        PublicClientApplication.Builder builder = PublicClientApplication.builder(clientId);
        builder.authority(authority);
        msalApp = builder.build();
    }
    
    public IAuthenticationResult signIn(String[] scopes) throws Exception {
        IAccount account = getAccount();
        
        IAuthenticationResult result;
        try {
            SilentParameters silentParameters = SilentParameters.builder(
                Arrays.asList(scopes),
                account)
                .build();
            result = msalApp.acquireTokenSilently(silentParameters).join();
        } catch (Exception ex) {
            InteractiveRequestParameters parameters = InteractiveRequestParameters.builder(new URI("http://localhost"))
                .scopes(Arrays.asList(scopes))
                .build();
            result = msalApp.acquireToken(parameters).join();
        }
        return result;
    }
    
    private IAccount getAccount() {
        Set<IAccount> accounts = msalApp.getAccounts().join();
        return accounts.isEmpty() ? null : accounts.iterator().next();
    }
}

Python

# Example authentication implementation
from msal import PublicClientApplication

class AuthClient:
    def __init__(self, client_id, authority):
        self.msal_app = PublicClientApplication(
            client_id=client_id,
            authority=authority
        )
    
    def sign_in(self, scopes):
        accounts = self.msal_app.get_accounts()
        
        if accounts:
            # Try to acquire token silently
            result = self.msal_app.acquire_token_silent(
                scopes=scopes,
                account=accounts[0]
            )
        else:
            result = None
            
        # If silent acquisition fails, fall back to interactive
        if not result:
            result = self.msal_app.acquire_token_interactive(scopes=scopes)
            
        return result

Getting Started

To begin implementing these capabilities:

1. Review the onboarding documentation to set up your tenant and authentication
2. Explore the notifications API to implement user communication channels
3. Configure telemetry standards for monitoring your application
4. Utilize the website builder to rapidly deploy a branded web experience
5. Apply the styling guidelines for consistent visual design

For additional assistance or to report documentation issues, please contact the platform team at platform-dev@lightstone.co.za.