Nesco.LicenseActivation.Blazor 1.0.1

🔐 LicenseActivation.Components

A comprehensive Blazor component library for software license activation with advanced browser fingerprinting, duplicate detection, and flexible UI options.

🌟 Features

• 🎨 Flexible UI Options

  • MudBlazor-based components for rich Material Design UI
  • Simple HTML/CSS components for lightweight deployments
  • Fully customizable styling and theming

• 🔒 Advanced Security

  • Browser fingerprinting for device identification
  • Duplicate activation detection
  • Secure license validation with secret keys
  • Support for multiple activation constraints

• 📱 Multi-Platform Support

  • Blazor Server
  • Blazor WebAssembly
  • Blazor Hybrid applications

• 🛠️ Developer-Friendly

  • Clean service-based architecture
  • Dependency injection support
  • Comprehensive API for customization
  • TypeScript-quality IntelliSense

📦 Installation

Package Manager Console

Install-Package Nesco.LicenseActivation.Blazor

Components Available

This package provides two license activation components:

1. LicenseActivationComponent - Full-featured component using MudBlazor
2. BasicLicenseActivationComponent - Lightweight component using only HTML/CSS/JS

Choose the component that best fits your project requirements:

When to use LicenseActivationComponent:

• ✅ Your project already uses MudBlazor
• ✅ You want a professional Material Design UI
• ✅ You need advanced UI features and animations
• ✅ You prefer the pre-built sophisticated design

When to use BasicLicenseActivationComponent:

• ✅ Your project doesn't use MudBlazor
• ✅ You want to minimize dependencies
• ✅ You need a lightweight solution
• ✅ You want to customize the styling completely
• ✅ You're building a minimal or headless application

Quick Start

Option A: Using MudBlazor Component (Recommended)

1. Add Services to Program.cs

using LicenseActivation.BlazorComponent.Extensions;
using MudBlazor.Services;

var builder = WebApplication.CreateBuilder(args);

// Add MudBlazor services (required)
builder.Services.AddMudServices();

// Add License Activation component services
builder.Services.AddLicenseActivationComponent();

// Add other services...
builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();

var app = builder.Build();

// Configure pipeline...
app.UseStaticFiles();
app.UseRouting();
app.MapRazorPages();
app.MapBlazorHub();
app.MapFallbackToPage("/_Host");

app.Run();

2. Add Component to Your Page

@page "/license"
@using LicenseActivation.BlazorComponent

<LicenseActivationComponent 
    ApiBaseUrl="https://your-license-api.com"
    OnActivationSuccess="OnActivationSuccess"
    OnActivationError="OnActivationError"
    OnShowMessage="OnShowMessage" />

@code {
    private async Task OnActivationSuccess(LicenseActivationResult result)
    {
        // Handle successful activation
        Console.WriteLine($"License activated: {result.ProductName}");
    }

    private async Task OnActivationError(string error)
    {
        // Handle activation error
        Console.WriteLine($"Activation failed: {error}");
    }

    private async Task OnShowMessage(LicenseActivationMessage message)
    {
        // Handle user messages (optional - for custom notifications)
        Console.WriteLine($"{message.Type}: {message.Message}");
    }
}

3. Or Use the Pre-built Page

Add the route to your app and the component will be available at /license-activation:

@page "/license"
@using LicenseActivation.BlazorComponent

<LicenseActivationPage ApiBaseUrl="https://your-license-api.com" />

Option B: Using Basic Component (No MudBlazor Required)

For projects that don't use MudBlazor, use the basic component:

1. Add Services to Program.cs

using LicenseActivation.BlazorComponent.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Add License Activation component services (no MudBlazor required)
builder.Services.AddLicenseActivationComponent();

// Configure the API base URL
builder.Services.Configure<LicenseActivationSettings>(options =>
{
    options.ApiBaseUrl = builder.Configuration["LicenseApi:BaseUrl"] ?? "https://localhost:7139";
});

// Add other services...
builder.Services.AddRazorPages();
builder.Services.AddServerSideBlazor();

var app = builder.Build();

// Configure pipeline...
app.UseStaticFiles();
app.UseRouting();
app.MapRazorPages();
app.MapBlazorHub();
app.MapFallbackToPage("/_Host");

app.Run();

2. Add Basic Component to Your Page

@page "/license"
@using LicenseActivation.BlazorComponent

<BasicLicenseActivationComponent 
    ApiBaseUrl="https://your-license-api.com"
    OnActivationSuccess="OnActivationSuccess"
    OnActivationError="OnActivationError"
    OnShowMessage="OnShowMessage" />

@code {
    private async Task OnActivationSuccess(LicenseActivationResult result)
    {
        // Handle successful activation
        Console.WriteLine($"License activated: {result.ProductName}");
    }

    private async Task OnActivationError(string error)
    {
        // Handle activation error
        Console.WriteLine($"Activation failed: {error}");
    }

    private async Task OnShowMessage(LicenseActivationMessage message)
    {
        // Handle user messages
        Console.WriteLine($"{message.Type}: {message.Message}");
    }
}

3. Or Use the Pre-built Basic Page

Add the route to your app and the component will be available at /basic-license-activation:

@page "/license"
@using LicenseActivation.BlazorComponent

<BasicLicenseActivationPage ApiBaseUrl="https://your-license-api.com" />

Configuration Options

Both LicenseActivationComponent and BasicLicenseActivationComponent support the following parameters:

Events

The component provides three main events:

OnActivationSuccess

Fired when license activation succeeds:

private async Task OnActivationSuccess(LicenseActivationResult result)
{
    // result.Success - Always true for this event
    // result.LicenseKey - The activated license key
    // result.ActivationId - Unique activation identifier
    // result.ProductName - Name of the licensed product
    // result.LicensedTo - Who the license is registered to
    // result.ExpiryDate - When the license expires (if applicable)
    // result.Params - Product-specific parameters (JSON string)
    // result.Response - Raw API response
}

OnActivationError

Fired when license activation fails:

private async Task OnActivationError(string error)
{
    // error - Description of what went wrong
}

OnShowMessage

Fired when the component wants to show a message to the user:

private async Task OnShowMessage(LicenseActivationMessage message)
{
    // message.Message - The message text
    // message.Type - Info, Success, Warning, or Error
}

License File Format

The component expects license files in JSON format:

{
  "LicenseKey": "12345678-1234-1234-1234-123456789012",
  "SecretKey": "your-secret-key-here",
  "Params": "{\"features\": [\"feature1\", \"feature2\"], \"maxUsers\": 100}"
}

Note: The Params field is optional and contains product-specific parameters as a JSON string. It can be used to pass configuration, feature flags, limits, or any custom data specific to your product.

API Integration

Your license activation API should support the following endpoints:

POST /api/LicenseActivation/check-duplicate

Check for duplicate activations before activating.

Request:

{
  "LicenseKey": "guid",
  "SecretKey": "string",
  "MachineId": "string",
  "ApplicationVersion": "string",
  "MachineFingerprint": "string"
}

Response:

{
  "HasDuplicate": false,
  "ClientType": "Web Browser",
  "MachineFingerprint": "fingerprint-hash",
  "ExistingActivation": null
}

POST /api/LicenseActivation/activate

Activate the license.

Request:

{
  "LicenseKey": "guid",
  "SecretKey": "string",
  "MachineId": "string",
  "ApplicationVersion": "string",
  "MachineFingerprint": "string",
  "ForceDuplicateActivation": false
}

Response:

{
  "Success": true,
  "ActivationId": "guid",
  "LicenseKey": "guid",
  "ProductName": "Your Product",
  "LicensedTo": "Customer Name",
  "ExpiryType": "FixedDate",
  "ExpiryDate": "2024-12-31T23:59:59Z",
  "MaxActivations": 5,
  "CurrentActivations": 1,
  "ActivatedAt": "2024-01-01T10:00:00Z",
  "Params": "{\"features\": [\"feature1\", \"feature2\"], \"maxUsers\": 100}"
}

POST /api/LicenseActivation/heartbeat/{activationId}

Send heartbeat to check license validity and update last heartbeat timestamp.

Path Parameters:

• activationId (Guid) - The activation ID to check

Request: No request body required.

Response:

{
  "isValid": true,
  "isActiveActivation": true,
  "isValidLicense": true,
  "activationId": "guid",
  "licenseKey": "guid", 
  "productName": "Your Product",
  "licensedTo": "Customer Name",
  "expiryType": "FixedDate",
  "expiryDate": "2024-12-31T23:59:59Z",
  "expiryDays": null,
  "activatedAt": "2024-01-01T10:00:00Z",
  "lastHeartbeat": "2024-01-15T14:30:00Z",
  "params": "{\"features\": [\"feature1\", \"feature2\"], \"maxUsers\": 100}"
}

Heartbeat Functionality

Both LicenseActivationComponent and BasicLicenseActivationComponent include a heartbeat helper method:

// Get a reference to the component
@ref var activationComponent

// Call heartbeat method
var response = await activationComponent.SendHeartbeatAsync(activationId);

if (response != null && response.IsValid)
{
    // License is valid
    Console.WriteLine($"License valid for {response.ProductName}");
    Console.WriteLine($"Expires: {response.ExpiryDate}");
}
else
{
    // License is invalid or expired
    Console.WriteLine("License is no longer valid");
}

The heartbeat method:

• Checks if the license activation is still valid
• Updates the last heartbeat timestamp on the server
• Returns comprehensive license status information
• Automatically shows success/warning messages to the user

Browser Fingerprinting

The component uses advanced browser fingerprinting to create unique device identifiers:

• User Agent - Browser and OS information
• Screen Properties - Resolution, color depth, pixel depth
• Hardware - CPU cores, memory (if available)
• WebGL - Graphics card vendor and renderer
• Canvas - Unique rendering characteristics
• Audio - Audio context fingerprinting
• Fonts - Available system fonts
• Timezone - User's timezone and offset
• Storage - Available storage types
• Network - Connection information (if available)

All properties are hashed using SHA-256 to create a unique fingerprint while maintaining privacy.

Styling

The component uses MudBlazor components and follows Material Design principles. You can customize the appearance using MudBlazor's theming system.

Requirements

• .NET 9.0 or later
• Blazor Server or Blazor WebAssembly
• MudBlazor 8.0 or later

Browser Support

• Chrome/Edge 88+
• Firefox 85+
• Safari 14+
• Mobile browsers with modern JavaScript support

License

MIT License - see LICENSE file for details.

Support

For issues and questions:

• Create an issue on GitHub
• Check the documentation
• Review the sample implementations

Contributing

Contributions are welcome! Please:

1. Fork the repository
2. Create a feature branch
3. Add tests for new functionality
4. Submit a pull request

Built with ❤️ using Blazor and MudBlazor