# Create a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install core libraries for PII detection and environment management
pip install microsoft-presidio presidio-analyzer presidio-anonymizer spacy python-dotenv pandas
# Download the necessary NLP model for entity recognition
python -m spacy download en_core_web_lg

# Initialize project
npm init -y

# Install dependencies
# We use @tensorflow/tfjs for local processing or standard axios for API-based DLP
npm install axios dotenv typescript ts-node @types/node

import os
from typing import Dict, Any
from dotenv import load_dotenv
from presidio_analyzer import AnalyzerEngine
from presidio_anonymizer import AnonymizerEngine

# Load environment variables
load_dotenv()

class DataGuard:
    """
    A production-ready class to detect and redact PII from sensitive datasets.
    """
    def __init__(self):
        # Initialize the engines
        self.analyzer = AnalyzerEngine()
        self.anonymizer = AnonymizerEngine()

    def scan_and_protect(self, text: str) -> Dict[str, Any]:
        """
        Analyzes text for PII and returns both the original and the sanitized version.
        """
        try:
            if not text:
                raise ValueError("Input text cannot be empty")

            # 1. Analyze text for entities (PERSON, EMAIL_ADDRESS, US_SSN, etc.)
            analysis_results = self.analyzer.analyze(
                text=text, 
                language='en', 
                entities=["PERSON", "EMAIL_ADDRESS", "US_SSN", "PHONE_NUMBER"]
            )

            # 2. Anonymize the detected entities
            anonymized_result = self.anonymizer.anonymize(
                text=text,
                analyzer_results=analysis_results
            )

            return {
                "status": "success",
                "original_text": text,
                "sanitized_text": anonymized_result.text,
                "detected_entities": [res.entity_type for res in analysis_results]
            }
        except Exception as e:
            return {
                "status": "error",
                "message": str(e)
            }

# --- TEST SUITE ---
if __name__ == "__main__":
    guard = DataGuard()
    
    # Simulated sensitive data (similar to what might be in a DentaQuest record)
    sample_data = "Customer John Doe with SSN 999-00-1234 can be reached at john.doe@example.com"
    
    result = guard.scan_and_protect(sample_data)
    
    if result["status"] == "success":
        print(f"✅ [SAFE]: {result['sanitized_text']}")
        print(f"🔍 [DETECTED]: {result['detected_entities']}")
    else:
        print(f"❌ [ERROR]: {result['message']}")

import axios from 'axios';
import * as dotenv from 'dotenv';

dotenv.config();

interface ScanResult {
    originalText: string;
    isSensitive: boolean;
    error?: string;
}

/**
 * DataScrubService handles communication with a centralized 
 * DLP (Data Loss Prevention) microservice.
 */
class DataScrubService {
    private readonly apiUrl: string;
    private readonly apiKey: string | undefined;

    constructor() {
        this.apiUrl = process.env.DLP_SERVICE_URL || '';
        this.apiKey = process.env.DLP_API_KEY;
    }

    /**
     * Scans text for sensitive information via an external API.
     * Implements robust error handling for network/API failures.
     */
    async scanText(text: string): Promise<ScanResult> {
        if (!this.apiKey) {
            throw new Error("DLP_API_KEY is not configured in environment variables.");
        }

        try {
            const response = await axios.post(
                `${this.apiUrl}/v1/inspect`,
                { content: text },
                {
                    headers: {
                        'Authorization': `Bearer ${this.apiKey}`,
                        'Content-Type': 'application/json'
                    },
                    timeout: 5000 // 5-second timeout to prevent blocking the event loop
                }
            );

            // Logic assumes the API returns a list of detected entity types
            const sensitiveEntities = response.data.entities || [];
            
            return {
                originalText: text,
                isSensitive: sensitiveEntities.length > 0
            };
        } catch (error: any) {
            return {
                originalText: text,
                isSensitive: false,
                error: error.response?.data?.message || error.message
            };
        }
    }
}

// --- TEST SUITE ---
async function runDemo() {
    const scrubber = new DataScrubService();
    const rawData = "Contact us at support@dentaquest-fake.com for help.";

    console.log("🚀 Starting PII Scan...");
    const result = await scrubber.scanText(rawData);

    if (result.error) {
        console.error(`⚠️ Scan failed: ${result.error}`);
    } else {
        console.log(`🛡️ Sensitive Data Detected: ${result.isSensitive}`);
        console.log(`📄 Original: ${result.originalText}`);
    }
}

runDemo();

# Local NLP Settings
NLP_MODEL_TYPE=en_core_web_lg

# Cloud DLP Settings (Production)
DLP_SERVICE_URL=https://dlp.googleapis.com/v2/projects/my-project/locations/global/inspectJobs
DLP_API_KEY=your_secure_google_api_key_here

# Logging Levels
LOG_LEVEL=info