QuantumLock™ Modelos de Licença

Tipos de Licenciamento Disponíveis

O QuantumLock™ suporta diversos modelos de licenciamento para atender diferentes necessidades de negócio.

📋 Índice

Visão Geral
Licença Perpétua
Licença por Assinatura
Licença Flutuante
Licença Node-Locked
Licença por Feature
Licença Trial
Licença Enterprise
Implementação

Visão Geral

Modelo	Duração	Binding	Caso de Uso
Perpétua	Infinito	Nenhum	Compra única
Assinatura	Tempo limitado	Nenhum	SaaS/Recorrente
Flutuante	Variável	Pool de licenças	Corporativo
Node-Locked	Variável	Hardware	Alta segurança
Feature	Variável	Por feature	Modular
Trial	Curto prazo	Tempo	Avaliação
Enterprise	Anual	Customizado	Grandes clientes

Licença Perpétua

Licença sem data de expiração. O cliente paga uma vez e usa para sempre.

Características

✅ Sem expiração
✅ Pagamento único
⚠️ Pode incluir período de suporte/updates
⚠️ Features congeladas na versão da compra

Implementação

# Gerar licença perpétua (valid_days muito alto)
license = client.generate_license(
    end_customer_id="cliente@empresa.com",
    features=["perpetual", "version_2.x"],
    valid_days=36500,  # 100 anos
    metadata={
        "type": "perpetual",
        "version": "2.0",
        "support_until": "2026-12-26"
    }
)

Validação

def is_perpetual_valid(validator: LicenseValidator) -> bool:
    """Verifica licença perpétua com suporte expirado"""
    if not validator._is_valid:
        return False

    info = validator.get_license_info()

    # Perpétua sempre válida para uso
    if "perpetual" in info.get("features", []):
        return True

    # Verificar suporte para updates
    support_until = info.get("metadata", {}).get("support_until")
    if support_until:
        # Bloquear updates após expiração do suporte
        pass

    return False

Licença por Assinatura

Licença válida por período definido, renovável automaticamente.

Características

📅 Período fixo (mensal, anual)
🔄 Renovação automática/manual
💰 Pagamento recorrente
📈 Acesso a updates contínuos

Planos Típicos

Plano	Duração	Features
Mensal	30 dias	Básicas
Anual	365 dias	Básicas + Premium
Anual+	365 dias	Todas + Suporte

Implementação

# Planos de assinatura
SUBSCRIPTION_PLANS = {
    "monthly_basic": {
        "days": 30,
        "features": ["basic"],
        "price": 29.90
    },
    "annual_premium": {
        "days": 365,
        "features": ["basic", "premium", "api_access"],
        "price": 299.90
    },
    "annual_enterprise": {
        "days": 365,
        "features": ["basic", "premium", "api_access", "enterprise", "support"],
        "price": 999.90
    }
}

def create_subscription(customer: str, plan: str) -> dict:
    plan_data = SUBSCRIPTION_PLANS[plan]

    license = client.generate_license(
        end_customer_id=customer,
        features=plan_data["features"],
        valid_days=plan_data["days"],
        metadata={
            "type": "subscription",
            "plan": plan,
            "renewable": True
        }
    )

    return license

Renovação

def renew_subscription(license_key: str, customer: str) -> dict:
    """Renova assinatura existente"""

    # Buscar licença atual
    current = get_license_from_db(license_key)

    # Gerar nova licença com mesmas features
    new_license = client.generate_license(
        end_customer_id=customer,
        features=current.features,
        valid_days=current.plan_days,
        metadata={
            "type": "subscription",
            "renewed_from": license_key,
            "renewal_count": current.renewal_count + 1
        }
    )

    # Desativar licença antiga
    deactivate_license(license_key)

    return new_license

Licença Flutuante

Pool de licenças compartilhadas entre múltiplos usuários.

Características

👥 N licenças para M usuários (N < M)
🔀 Check-in/Check-out
📊 Monitoramento de uso
🏢 Ideal para empresas

Arquitetura

┌─────────────────────────────────────────────────────────────────┐
│                    LICENSE SERVER                                │
├─────────────────────────────────────────────────────────────────┤
│  Pool: 10 licenças                                              │
│  Em uso: 7                                                       │
│  Disponíveis: 3                                                  │
├─────────────────────────────────────────────────────────────────┤
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐   │
│  │ User 1  │ │ User 2  │ │ User 3  │ │ User 4  │ │ User 5  │   │
│  │ (ativo) │ │ (ativo) │ │(disponí)│ │ (ativo) │ │ (ativo) │   │
│  └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘   │
└─────────────────────────────────────────────────────────────────┘

Implementação

import redis
from datetime import datetime, timedelta

class FloatingLicenseManager:
    """Gerenciador de licenças flutuantes"""

    def __init__(self, license_key: str, max_seats: int):
        self.license_key = license_key
        self.max_seats = max_seats
        self.redis = redis.Redis()
        self.key_prefix = f"floating:{license_key}"

    def checkout(self, user_id: str, duration_minutes: int = 60) -> bool:
        """Reserva uma licença para o usuário"""

        # Verificar se já tem checkout
        if self.redis.exists(f"{self.key_prefix}:user:{user_id}"):
            # Renovar checkout
            self.redis.expire(
                f"{self.key_prefix}:user:{user_id}",
                duration_minutes * 60
            )
            return True

        # Verificar disponibilidade
        current = self.redis.scard(f"{self.key_prefix}:active")
        if current >= self.max_seats:
            return False  # Sem licenças disponíveis

        # Fazer checkout
        self.redis.sadd(f"{self.key_prefix}:active", user_id)
        self.redis.setex(
            f"{self.key_prefix}:user:{user_id}",
            duration_minutes * 60,
            datetime.now().isoformat()
        )

        return True

    def checkin(self, user_id: str):
        """Libera a licença do usuário"""
        self.redis.srem(f"{self.key_prefix}:active", user_id)
        self.redis.delete(f"{self.key_prefix}:user:{user_id}")

    def get_status(self) -> dict:
        """Status do pool de licenças"""
        active = self.redis.smembers(f"{self.key_prefix}:active")
        return {
            "total": self.max_seats,
            "in_use": len(active),
            "available": self.max_seats - len(active),
            "active_users": [u.decode() for u in active]
        }


# Uso
manager = FloatingLicenseManager(
    license_key="QLOCK-FLOAT-XXXX",
    max_seats=10
)

# Usuário tenta usar
if manager.checkout("user123"):
    print("Licença obtida!")
    # ... usar software ...
    manager.checkin("user123")
else:
    print("Sem licenças disponíveis")

Licença Node-Locked

Licença vinculada a hardware específico.

Características

🔒 Vinculada a máquina específica
🖥️ Fingerprint de hardware
🛡️ Alta segurança
⚠️ Requer reativação se hardware mudar

Fingerprint de Hardware

import hashlib
import platform
import uuid
import subprocess

def get_hardware_fingerprint() -> str:
    """Gera fingerprint único do hardware"""

    components = []

    # CPU ID
    try:
        if platform.system() == "Linux":
            result = subprocess.run(
                ["cat", "/proc/cpuinfo"],
                capture_output=True, text=True
            )
            for line in result.stdout.split("\n"):
                if "Serial" in line or "model name" in line:
                    components.append(line)
        elif platform.system() == "Darwin":  # macOS
            result = subprocess.run(
                ["sysctl", "-n", "machdep.cpu.brand_string"],
                capture_output=True, text=True
            )
            components.append(result.stdout.strip())
    except:
        pass

    # MAC Address
    mac = hex(uuid.getnode())
    components.append(mac)

    # Hostname
    components.append(platform.node())

    # OS info
    components.append(platform.platform())

    # Gerar hash
    fingerprint_data = "|".join(components)
    return hashlib.sha256(fingerprint_data.encode()).hexdigest()[:32]


def validate_node_locked(validator: LicenseValidator) -> bool:
    """Valida licença node-locked"""

    if not validator._is_valid:
        return False

    info = validator.get_license_info()
    licensed_fingerprint = info.get("metadata", {}).get("hardware_fingerprint")

    if not licensed_fingerprint:
        return True  # Não é node-locked

    current_fingerprint = get_hardware_fingerprint()

    return licensed_fingerprint == current_fingerprint

Gerar Licença Node-Locked

def generate_node_locked_license(
    customer: str,
    hardware_fingerprint: str,
    features: list
) -> dict:
    """Gera licença vinculada a hardware"""

    return client.generate_license(
        end_customer_id=customer,
        features=features + ["node_locked"],
        valid_days=365,
        metadata={
            "type": "node_locked",
            "hardware_fingerprint": hardware_fingerprint,
            "binding": "strict"
        }
    )

Licença por Feature

Licenciamento modular onde cada feature é vendida separadamente.

Características

🧩 Features individuais
💰 Pagamento por uso
📈 Upsell facilitado
🔄 Upgrades incrementais

Catálogo de Features

FEATURE_CATALOG = {
    "basic": {
        "name": "Funcionalidades Básicas",
        "price": 0,
        "includes": ["file_export", "basic_reports"]
    },
    "premium": {
        "name": "Premium",
        "price": 99,
        "includes": ["advanced_reports", "api_access", "priority_support"]
    },
    "analytics": {
        "name": "Analytics Avançado",
        "price": 149,
        "includes": ["dashboards", "custom_reports", "data_export"]
    },
    "enterprise": {
        "name": "Enterprise",
        "price": 499,
        "includes": ["sso", "audit_logs", "custom_branding", "dedicated_support"]
    },
    "ai": {
        "name": "AI/ML",
        "price": 299,
        "includes": ["ml_predictions", "auto_insights", "nlp_queries"]
    }
}

def get_all_features(selected: list) -> list:
    """Expande features selecionadas para lista completa"""
    all_features = set(selected)

    for feature in selected:
        if feature in FEATURE_CATALOG:
            all_features.update(FEATURE_CATALOG[feature]["includes"])

    return list(all_features)

Upgrade de Features

def upgrade_license(
    current_license_key: str,
    customer: str,
    new_features: list
) -> dict:
    """Adiciona features a licença existente"""

    # Buscar licença atual
    current = get_license_from_db(current_license_key)

    # Combinar features
    all_features = list(set(current.features + new_features))

    # Gerar nova licença
    new_license = client.generate_license(
        end_customer_id=customer,
        features=all_features,
        valid_days=current.days_remaining,
        metadata={
            "type": "feature_upgrade",
            "upgraded_from": current_license_key,
            "added_features": new_features
        }
    )

    # Desativar antiga
    deactivate_license(current_license_key)

    return new_license

Licença Trial

Licença de avaliação por tempo limitado.

Características

⏱️ Período curto (7-30 dias)
🎁 Acesso a todas features (ou limitado)
🚫 Sem custo
🔄 Converte para paga

Implementação

def generate_trial_license(
    customer: str,
    trial_days: int = 14,
    full_features: bool = True
) -> dict:
    """Gera licença trial"""

    if full_features:
        features = ["trial", "basic", "premium", "analytics"]
    else:
        features = ["trial", "basic"]

    return client.generate_license(
        end_customer_id=customer,
        features=features,
        valid_days=trial_days,
        metadata={
            "type": "trial",
            "convertible": True,
            "trial_started": datetime.now().isoformat()
        }
    )


def check_trial_conversion(validator: LicenseValidator):
    """Verifica e notifica sobre fim do trial"""

    info = validator.get_license_info()

    if "trial" not in info.get("features", []):
        return None  # Não é trial

    valid_until = datetime.fromisoformat(
        info["valid_until"].replace("Z", "+00:00")
    )
    days_left = (valid_until - datetime.now(valid_until.tzinfo)).days

    if days_left <= 3:
        return {
            "status": "trial_ending",
            "days_left": days_left,
            "message": "Seu trial está acabando! Assine agora.",
            "upgrade_url": "https://mycompany.com/pricing"
        }

    return {"status": "trial_active", "days_left": days_left}

Anti-Abuse

def can_start_trial(customer_email: str) -> bool:
    """Verifica se cliente pode iniciar trial (anti-abuse)"""

    # Verificar trials anteriores
    previous_trials = get_trials_by_email(customer_email)

    if previous_trials:
        return False  # Já usou trial

    # Verificar domínio (anti-alias)
    domain = customer_email.split("@")[1]
    domain_trials = get_trials_by_domain(domain)

    if len(domain_trials) > 5:
        return False  # Muitos trials do mesmo domínio

    return True

Licença Enterprise

Licenciamento customizado para grandes clientes.

Características

🏢 Contrato anual/multi-anual
💼 Termos customizados
🎯 Features sob medida
📞 Suporte dedicado
📊 SLAs garantidos

Componentes Enterprise

@dataclass
class EnterpriseLicense:
    """Licença enterprise customizada"""

    # Básico
    customer_id: str
    contract_id: str

    # Período
    start_date: datetime
    end_date: datetime

    # Usuários
    named_users: int  # Usuários nomeados
    concurrent_users: int  # Usuários simultâneos

    # Features
    features: list
    custom_features: list

    # Limites
    api_calls_month: int
    storage_gb: int

    # Suporte
    support_tier: str  # "standard", "priority", "dedicated"
    sla_uptime: float  # 99.9, 99.99

    # Termos
    auto_renew: bool
    payment_terms: str  # "net30", "net60"


def generate_enterprise_license(config: EnterpriseLicense) -> dict:
    """Gera licença enterprise"""

    all_features = config.features + config.custom_features + [
        "enterprise",
        f"users_{config.named_users}",
        f"concurrent_{config.concurrent_users}",
        f"support_{config.support_tier}"
    ]

    days = (config.end_date - config.start_date).days

    return client.generate_license(
        end_customer_id=config.customer_id,
        features=all_features,
        valid_days=days,
        metadata={
            "type": "enterprise",
            "contract_id": config.contract_id,
            "named_users": config.named_users,
            "concurrent_users": config.concurrent_users,
            "api_calls_month": config.api_calls_month,
            "storage_gb": config.storage_gb,
            "support_tier": config.support_tier,
            "sla_uptime": config.sla_uptime,
            "auto_renew": config.auto_renew
        }
    )

Implementação

Seletor de Modelo

class LicenseFactory:
    """Factory para criar diferentes tipos de licença"""

    def __init__(self, client: QuantumLockClient):
        self.client = client

    def create(
        self,
        license_type: str,
        customer: str,
        **kwargs
    ) -> dict:
        """Cria licença do tipo especificado"""

        creators = {
            "perpetual": self._create_perpetual,
            "subscription": self._create_subscription,
            "trial": self._create_trial,
            "floating": self._create_floating,
            "node_locked": self._create_node_locked,
            "enterprise": self._create_enterprise,
        }

        creator = creators.get(license_type)
        if not creator:
            raise ValueError(f"Tipo desconhecido: {license_type}")

        return creator(customer, **kwargs)

    def _create_perpetual(self, customer: str, features: list = None, **kwargs):
        return self.client.generate_license(
            end_customer_id=customer,
            features=features or ["perpetual", "basic"],
            valid_days=36500,
            metadata={"type": "perpetual"}
        )

    def _create_subscription(self, customer: str, plan: str = "monthly", **kwargs):
        plans = {
            "monthly": (30, ["basic"]),
            "annual": (365, ["basic", "premium"]),
        }
        days, features = plans.get(plan, (30, ["basic"]))

        return self.client.generate_license(
            end_customer_id=customer,
            features=features,
            valid_days=days,
            metadata={"type": "subscription", "plan": plan}
        )

    def _create_trial(self, customer: str, days: int = 14, **kwargs):
        return self.client.generate_license(
            end_customer_id=customer,
            features=["trial", "basic", "premium"],
            valid_days=days,
            metadata={"type": "trial"}
        )

    # ... outros métodos


# Uso
factory = LicenseFactory(client)

# Criar diferentes tipos
trial = factory.create("trial", "user@email.com")
subscription = factory.create("subscription", "user@email.com", plan="annual")
perpetual = factory.create("perpetual", "user@email.com", features=["premium"])

📞 Suporte

Email: support@softquantus.com
Portal: https://portal.softquantus.com
Docs: https://docs.softquantus.com

Tipos de Licenciamento Disponíveis​

📋 Índice​

Visão Geral​

Licença Perpétua​

Características​

Implementação​

Validação​

Licença por Assinatura​

Características​

Planos Típicos​

Implementação​

Renovação​

Licença Flutuante​

Características​

Arquitetura​

Implementação​

Licença Node-Locked​

Características​

Fingerprint de Hardware​

Gerar Licença Node-Locked​

Licença por Feature​

Características​

Catálogo de Features​

Upgrade de Features​

Licença Trial​

Características​

Implementação​

Anti-Abuse​

Licença Enterprise​

Características​

Componentes Enterprise​

Implementação​

Seletor de Modelo​

📞 Suporte​

Tipos de Licenciamento Disponíveis

📋 Índice

Visão Geral

Licença Perpétua

Características

Implementação

Validação

Licença por Assinatura

Características

Planos Típicos

Implementação

Renovação

Licença Flutuante

Características

Arquitetura

Implementação

Licença Node-Locked

Características

Fingerprint de Hardware

Gerar Licença Node-Locked

Licença por Feature

Características

Catálogo de Features

Upgrade de Features

Licença Trial

Características

Implementação

Anti-Abuse

Licença Enterprise

Características

Componentes Enterprise

Implementação

Seletor de Modelo

📞 Suporte