Django integration

# myapp/middleware.py

from django.conf import settings
from django.utils.html import escape
from django.utils.safestring import mark_safe

class AnalyticsMiddleware:
    """
    Middleware to inject analytics script into HTML responses
    """
    
    def __init__(self, get_response):
        self.get_response = get_response
        
    def __call__(self, request):
        response = self.get_response(request)
        
        # Leave excluded paths untouched (the admin site by default, set ANALYTICS_EXCLUDE_PATHS to change it)
        excluded = getattr(settings, 'ANALYTICS_EXCLUDE_PATHS', ('/admin/',))
        if request.path.startswith(tuple(excluded)):
            return response

        # Only inject on HTML responses. Streamed or encoded bodies (for example gzipped by GZipMiddleware) are left alone
        if (
            getattr(settings, 'ANALYTICS_ENABLED', False) and
            response.get('Content-Type', '').startswith('text/html') and
            response.status_code == 200 and
            not response.streaming and
            not response.has_header('Content-Encoding')
        ):
            analytics_script = self._get_analytics_script(request)
            if analytics_script:
                charset = response.charset
                content = response.content.decode(charset)
                content = content.replace('</head>', f'{analytics_script}</head>')
                response.content = content.encode(charset)
                response['Content-Length'] = len(response.content)
        
        return response
    
    def _get_analytics_script(self, request):
        website_id = getattr(settings, 'ANALYTICS_WEBSITE_ID', '')
        domain = getattr(settings, 'ANALYTICS_DOMAIN', '') or request.get_host()
        script_url = getattr(settings, 'ANALYTICS_SCRIPT_URL', 'https://thebizness.ai/js/script.js')
        
        if not website_id:
            return ''
            
        return f'''
    <script async defer data-website-id="{escape(website_id)}" data-domain="{escape(domain)}" src="{escape(script_url)}"></script>'''

# myapp/templatetags/analytics_tags.py

from django import template
from django.conf import settings
from django.utils.html import escape
from django.utils.safestring import mark_safe

register = template.Library()

@register.simple_tag(takes_context=True)
def analytics_script(context):
    """
    Template tag to render analytics script
    Usage: {% load analytics_tags %} {% analytics_script %}
    """
    request = context.get('request')
    
    if not getattr(settings, 'ANALYTICS_ENABLED', False):
        return ''
    
    website_id = getattr(settings, 'ANALYTICS_WEBSITE_ID', '')
    if not website_id:
        return ''
    
    domain = getattr(settings, 'ANALYTICS_DOMAIN', '')
    if not domain and request:
        domain = request.get_host()
    
    script_url = getattr(settings, 'ANALYTICS_SCRIPT_URL', 'https://thebizness.ai/js/script.js')
    
    script = f'''<script async defer data-website-id="{escape(website_id)}" data-domain="{escape(domain)}" src="{escape(script_url)}"></script>'''
    
    return mark_safe(script)

@register.filter
def is_analytics_enabled(value):
    """
    Template filter to check if analytics is enabled
    Usage: {% if request|is_analytics_enabled %}
    """
    return getattr(settings, 'ANALYTICS_ENABLED', False)

# management/commands/setup_analytics.py

from django.core.management.base import BaseCommand
from django.conf import settings
import os

class Command(BaseCommand):
    help = 'Setup theBizness analytics configuration'
    
    def add_arguments(self, parser):
        parser.add_argument('website_id', type=str, help='Your theBizness website ID')
        parser.add_argument('--domain', type=str, help='Your domain (optional)')
        parser.add_argument('--env-file', type=str, default='.env', help='Environment file path')
    
    def handle(self, *args, **options):
        website_id = options['website_id']
        domain = options.get('domain', '')
        env_file = options['env_file']
        
        # Update or create .env file
        env_vars = {
            'ANALYTICS_ENABLED': 'True',
            'ANALYTICS_WEBSITE_ID': website_id,
        }
        
        if domain:
            env_vars['ANALYTICS_DOMAIN'] = domain
        
        self._update_env_file(env_file, env_vars)
        
        self.stdout.write(
            self.style.SUCCESS(
                f'Analytics configuration updated successfully!\n'
                f'Website ID: {website_id}\n'
                f'Domain: {domain or "Auto-detected"}'
            )
        )
        
        if not domain:
            self.stdout.write(
                self.style.WARNING(
                    'No domain specified. Domain will be auto-detected from request.'
                )
            )
    
    def _update_env_file(self, env_file, variables):
        """Update or create environment file with new variables"""
        env_path = os.path.join(settings.BASE_DIR, env_file)

        # Read existing lines so comments, blank lines and their order are kept
        lines = []
        if os.path.exists(env_path):
            with open(env_path, 'r') as f:
                lines = f.read().splitlines()

        # Replace the value of each existing variable in place, and leave every other line as it was
        pending = dict(variables)
        for i, line in enumerate(lines):
            key = line.split('=', 1)[0].strip()
            if '=' in line and key in variables:
                lines[i] = f'{key}={variables[key]}'
                pending.pop(key, None)

        # Append the variables the file did not have yet
        lines.extend(f'{key}={value}' for key, value in pending.items())

        # Write back to file
        with open(env_path, 'w') as f:
            f.write('\n'.join(lines) + '\n')