@erosolaraijs/cure 1.0.1 → 1.0.2

package/dist/patient/patientPortal.js

@@ -0,0 +1,667 @@
+/**
+ * Patient-Facing Portal Interfaces
+ *
+ * Provides patient engagement features:
+ * - Treatment plan viewing
+ * - Side effect tracking
+ * - Medication adherence monitoring
+ * - Quality of life assessments
+ * - Secure messaging with care team
+ * - Educational content delivery
+ * - Appointment management
+ *
+ * All interfaces designed for health literacy and accessibility.
+ */
+import { EventEmitter } from 'events';
+// ═══════════════════════════════════════════════════════════════════════════════
+// PATIENT PORTAL SERVICE
+// ═══════════════════════════════════════════════════════════════════════════════
+export class PatientPortalService extends EventEmitter {
+    accounts = new Map();
+    treatmentSummaries = new Map();
+    symptomReports = new Map();
+    adherenceLogs = new Map();
+    qolAssessments = new Map();
+    messages = new Map();
+    educationalContent = new Map();
+    appointmentRequests = new Map();
+    constructor() {
+        super();
+        this.initializeEducationalContent();
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // ACCOUNT MANAGEMENT
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Create a patient portal account
+     */
+    async createAccount(accountData) {
+        const id = `PAT-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+        const account = {
+            ...accountData,
+            id,
+            createdAt: new Date()
+        };
+        this.accounts.set(id, account);
+        this.emit('account-created', { accountId: id, mrn: account.mrn });
+        return account;
+    }
+    /**
+     * Get patient account
+     */
+    getAccount(patientId) {
+        return this.accounts.get(patientId);
+    }
+    /**
+     * Record patient login
+     */
+    recordLogin(patientId) {
+        const account = this.accounts.get(patientId);
+        if (account) {
+            account.lastLoginAt = new Date();
+            this.emit('patient-login', { patientId });
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // TREATMENT SUMMARY
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Set patient treatment summary
+     */
+    setTreatmentSummary(summary) {
+        this.treatmentSummaries.set(summary.patientId, summary);
+        this.emit('treatment-summary-updated', { patientId: summary.patientId });
+    }
+    /**
+     * Get patient-friendly treatment summary
+     */
+    getTreatmentSummary(patientId) {
+        return this.treatmentSummaries.get(patientId);
+    }
+    /**
+     * Generate simple language summary
+     */
+    generateSimpleSummary(diagnosis, stage, treatment) {
+        // Convert medical terminology to patient-friendly language
+        const diagnosisExplanation = this.simplifyDiagnosis(diagnosis, stage);
+        const treatmentExplanation = this.simplifyTreatment(treatment);
+        const whatItMeans = [
+            'Your care team has created a treatment plan specifically for you',
+            'This plan is based on the specific characteristics of your cancer',
+            'Your doctors will monitor how well the treatment is working',
+            'You can ask questions at any time - your care team is here to help'
+        ];
+        return {
+            diagnosisExplanation,
+            treatmentExplanation,
+            whatItMeans
+        };
+    }
+    simplifyDiagnosis(diagnosis, stage) {
+        // Simplified explanations for common diagnoses
+        const simplifications = {
+            'NSCLC': 'non-small cell lung cancer, the most common type of lung cancer',
+            'SCLC': 'small cell lung cancer',
+            'Breast Cancer': 'breast cancer',
+            'Adenocarcinoma': 'a type of cancer that starts in gland cells',
+            'Squamous Cell Carcinoma': 'a type of cancer that starts in flat cells'
+        };
+        let explanation = `You have been diagnosed with ${simplifications[diagnosis] || diagnosis}. `;
+        // Stage explanation
+        if (stage) {
+            const stageNum = stage.replace(/[^IViv0-4]/g, '').toUpperCase();
+            if (stageNum.includes('I') && !stageNum.includes('V')) {
+                explanation += 'This is an early stage, which often has more treatment options.';
+            }
+            else if (stageNum.includes('II')) {
+                explanation += 'This stage means the cancer has grown but is still considered treatable.';
+            }
+            else if (stageNum.includes('III')) {
+                explanation += 'This is a more advanced stage, but many effective treatments are available.';
+            }
+            else if (stageNum.includes('IV')) {
+                explanation += 'This stage means the cancer has spread, and treatment focuses on controlling the disease and maintaining quality of life.';
+            }
+        }
+        return explanation;
+    }
+    simplifyTreatment(treatment) {
+        const explanations = {
+            'immunotherapy': 'a treatment that helps your immune system fight the cancer',
+            'chemotherapy': 'medicine that kills fast-growing cells, including cancer cells',
+            'targeted therapy': 'medicine that targets specific features of cancer cells',
+            'radiation': 'high-energy beams that destroy cancer cells in a specific area',
+            'surgery': 'an operation to remove the cancer'
+        };
+        let explanation = treatment;
+        for (const [term, simple] of Object.entries(explanations)) {
+            if (treatment.toLowerCase().includes(term)) {
+                explanation = `Your treatment includes ${simple}.`;
+                break;
+            }
+        }
+        return explanation;
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // SYMPTOM TRACKING
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Submit a symptom report
+     */
+    async submitSymptomReport(patientId, symptoms, overallFeeling, concerns) {
+        const id = `SYM-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+        // Analyze symptoms for follow-up needs
+        const { requiresFollowUp, followUpReason } = this.analyzeSymptoms(symptoms, overallFeeling);
+        const report = {
+            id,
+            patientId,
+            reportedAt: new Date(),
+            symptoms,
+            overallFeeling,
+            concernsForDoctor: concerns,
+            requiresFollowUp,
+            followUpReason
+        };
+        const patientReports = this.symptomReports.get(patientId) || [];
+        patientReports.push(report);
+        this.symptomReports.set(patientId, patientReports);
+        this.emit('symptom-report-submitted', { patientId, reportId: id, requiresFollowUp });
+        // Alert care team if needed
+        if (requiresFollowUp) {
+            this.emit('symptom-alert', {
+                patientId,
+                reportId: id,
+                reason: followUpReason,
+                severity: this.determineSeverity(symptoms)
+            });
+        }
+        return report;
+    }
+    /**
+     * Get symptom history for patient
+     */
+    getSymptomHistory(patientId, days) {
+        const reports = this.symptomReports.get(patientId) || [];
+        if (!days)
+            return reports;
+        const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+        return reports.filter(r => r.reportedAt >= cutoff);
+    }
+    /**
+     * Get symptom trends
+     */
+    getSymptomTrends(patientId) {
+        const reports = this.getSymptomHistory(patientId, 30);
+        const symptomData = new Map();
+        for (const report of reports) {
+            for (const symptom of report.symptoms) {
+                const data = symptomData.get(symptom.symptom) || [];
+                data.push(symptom.severity);
+                symptomData.set(symptom.symptom, data);
+            }
+        }
+        const trends = [];
+        for (const [symptom, severities] of symptomData) {
+            const avg = severities.reduce((a, b) => a + b, 0) / severities.length;
+            // Determine trend
+            let trend = 'stable';
+            if (severities.length >= 3) {
+                const recent = severities.slice(-3);
+                const earlier = severities.slice(0, Math.max(1, severities.length - 3));
+                const recentAvg = recent.reduce((a, b) => a + b, 0) / recent.length;
+                const earlierAvg = earlier.reduce((a, b) => a + b, 0) / earlier.length;
+                if (recentAvg < earlierAvg - 0.5)
+                    trend = 'improving';
+                else if (recentAvg > earlierAvg + 0.5)
+                    trend = 'worsening';
+            }
+            trends.push({
+                symptom,
+                trend,
+                averageSeverity: Math.round(avg * 10) / 10,
+                occurrences: severities.length
+            });
+        }
+        return trends.sort((a, b) => b.averageSeverity - a.averageSeverity);
+    }
+    analyzeSymptoms(symptoms, overallFeeling) {
+        // Check for concerning symptoms
+        const concerningSymptoms = [
+            'fever', 'chest pain', 'shortness of breath', 'severe pain',
+            'bleeding', 'confusion', 'fainting', 'seizure'
+        ];
+        const severeSymptomsCount = symptoms.filter(s => s.severity >= 4).length;
+        const concerningFound = symptoms.find(s => concerningSymptoms.some(cs => s.symptom.toLowerCase().includes(cs)));
+        if (concerningFound && concerningFound.severity >= 3) {
+            return {
+                requiresFollowUp: true,
+                followUpReason: `Patient reported ${concerningFound.symptom} with severity ${concerningFound.severity}/5`
+            };
+        }
+        if (severeSymptomsCount >= 2) {
+            return {
+                requiresFollowUp: true,
+                followUpReason: `Multiple severe symptoms reported (${severeSymptomsCount})`
+            };
+        }
+        if (overallFeeling <= 2) {
+            return {
+                requiresFollowUp: true,
+                followUpReason: 'Patient overall feeling is very poor'
+            };
+        }
+        return { requiresFollowUp: false };
+    }
+    determineSeverity(symptoms) {
+        const maxSeverity = Math.max(...symptoms.map(s => s.severity));
+        if (maxSeverity >= 4)
+            return 'high';
+        if (maxSeverity >= 3)
+            return 'moderate';
+        return 'low';
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // MEDICATION ADHERENCE
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Log medication taken
+     */
+    logMedicationTaken(patientId, medication, scheduledTime, taken, takenTime, skippedReason, sideEffects) {
+        const logs = this.adherenceLogs.get(patientId) || [];
+        let medLog = logs.find(l => l.medication === medication);
+        if (!medLog) {
+            medLog = {
+                patientId,
+                medication,
+                logs: [],
+                adherenceRate: 100,
+                missedDoses: 0,
+                streakDays: 0
+            };
+            logs.push(medLog);
+        }
+        medLog.logs.push({
+            scheduledTime,
+            takenTime,
+            taken,
+            skippedReason,
+            sideEffects
+        });
+        // Update adherence metrics
+        const totalDoses = medLog.logs.length;
+        const takenDoses = medLog.logs.filter(l => l.taken).length;
+        medLog.adherenceRate = Math.round((takenDoses / totalDoses) * 100);
+        medLog.missedDoses = totalDoses - takenDoses;
+        // Calculate streak
+        const sortedLogs = [...medLog.logs].sort((a, b) => b.scheduledTime.getTime() - a.scheduledTime.getTime());
+        let streak = 0;
+        for (const log of sortedLogs) {
+            if (log.taken)
+                streak++;
+            else
+                break;
+        }
+        medLog.streakDays = streak;
+        this.adherenceLogs.set(patientId, logs);
+        this.emit('medication-logged', { patientId, medication, taken });
+        // Alert for poor adherence
+        if (medLog.adherenceRate < 80) {
+            this.emit('adherence-concern', {
+                patientId,
+                medication,
+                adherenceRate: medLog.adherenceRate
+            });
+        }
+    }
+    /**
+     * Get adherence summary
+     */
+    getAdherenceSummary(patientId) {
+        const medications = this.adherenceLogs.get(patientId) || [];
+        if (medications.length === 0) {
+            return {
+                medications: [],
+                overallAdherence: 100,
+                concerns: [],
+                encouragement: 'Great start! Remember to log your medications each day.'
+            };
+        }
+        const overallAdherence = Math.round(medications.reduce((sum, m) => sum + m.adherenceRate, 0) / medications.length);
+        const concerns = [];
+        for (const med of medications) {
+            if (med.adherenceRate < 80) {
+                concerns.push(`${med.medication} adherence is ${med.adherenceRate}% - please talk to your care team if you're having trouble`);
+            }
+        }
+        let encouragement;
+        if (overallAdherence >= 95) {
+            encouragement = 'Excellent! You\'re doing a great job staying on track with your medications.';
+        }
+        else if (overallAdherence >= 80) {
+            encouragement = 'Good work! Try to take your medications at the same time each day to build a routine.';
+        }
+        else {
+            encouragement = 'Remember, taking your medications as prescribed gives them the best chance to work. We\'re here to help if you\'re having difficulties.';
+        }
+        return { medications, overallAdherence, concerns, encouragement };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // QUALITY OF LIFE ASSESSMENTS
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Submit quality of life assessment
+     */
+    async submitQoLAssessment(patientId, assessmentType, responses) {
+        const id = `QOL-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+        // Score the assessment
+        const summaryScores = this.scoreAssessment(assessmentType, responses, patientId);
+        const alerts = this.identifyQoLAlerts(summaryScores);
+        const assessment = {
+            id,
+            patientId,
+            assessmentType,
+            completedAt: new Date(),
+            responses,
+            summaryScores,
+            alerts
+        };
+        const patientAssessments = this.qolAssessments.get(patientId) || [];
+        patientAssessments.push(assessment);
+        this.qolAssessments.set(patientId, patientAssessments);
+        this.emit('qol-assessment-completed', { patientId, assessmentId: id });
+        // Alert for concerning scores
+        if (alerts.some(a => a.severity === 'high')) {
+            this.emit('qol-alert', { patientId, assessmentId: id, alerts });
+        }
+        return assessment;
+    }
+    /**
+     * Get QoL assessment history
+     */
+    getQoLHistory(patientId) {
+        return this.qolAssessments.get(patientId) || [];
+    }
+    scoreAssessment(type, responses, patientId) {
+        // Group responses by category
+        const categories = new Map();
+        for (const response of responses) {
+            const cat = response.category;
+            const data = categories.get(cat) || { scores: [], maxScore: 0 };
+            data.scores.push(response.score || 0);
+            data.maxScore = Math.max(data.maxScore, 5); // Assuming 5-point scale
+            categories.set(cat, data);
+        }
+        // Get previous assessment for comparison
+        const history = this.qolAssessments.get(patientId) || [];
+        const previous = history.length > 0 ? history[history.length - 1] : null;
+        const summaryScores = [];
+        for (const [domain, data] of categories) {
+            const score = Math.round(data.scores.reduce((a, b) => a + b, 0) / data.scores.length * 10) / 10;
+            const maxScore = data.maxScore;
+            // Get previous score for this domain
+            let changeFromLast;
+            if (previous) {
+                const prevDomain = previous.summaryScores.find(s => s.domain === domain);
+                if (prevDomain) {
+                    changeFromLast = Math.round((score - prevDomain.score) * 10) / 10;
+                }
+            }
+            summaryScores.push({
+                domain,
+                score,
+                maxScore,
+                interpretation: this.interpretScore(score, maxScore),
+                changeFromLast
+            });
+        }
+        return summaryScores;
+    }
+    interpretScore(score, maxScore) {
+        const percentage = (score / maxScore) * 100;
+        if (percentage >= 80)
+            return 'Good - minimal impact on quality of life';
+        if (percentage >= 60)
+            return 'Moderate - some impact on daily activities';
+        if (percentage >= 40)
+            return 'Below average - noticeable impact on quality of life';
+        return 'Concerning - significant impact, please discuss with care team';
+    }
+    identifyQoLAlerts(scores) {
+        const alerts = [];
+        for (const score of scores) {
+            const percentage = (score.score / score.maxScore) * 100;
+            if (percentage < 40) {
+                alerts.push({
+                    domain: score.domain,
+                    concern: `${score.domain} score is below 40%`,
+                    severity: 'high',
+                    recommendation: 'Discuss with your care team at your next appointment'
+                });
+            }
+            else if (percentage < 60 && score.changeFromLast !== undefined && score.changeFromLast < -1) {
+                alerts.push({
+                    domain: score.domain,
+                    concern: `${score.domain} has declined since last assessment`,
+                    severity: 'moderate',
+                    recommendation: 'Monitor and report if continues to decline'
+                });
+            }
+        }
+        return alerts;
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // SECURE MESSAGING
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Send a message
+     */
+    async sendMessage(patientId, body, category, priority = 'routine', subject) {
+        const id = `MSG-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+        const threadId = `THR-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`;
+        const message = {
+            id,
+            threadId,
+            patientId,
+            direction: 'inbound',
+            sender: {
+                type: 'patient',
+                name: 'Patient', // Would be fetched from account
+                id: patientId
+            },
+            recipient: {
+                type: 'care-team',
+                name: 'Care Team'
+            },
+            subject,
+            body,
+            sentAt: new Date(),
+            priority,
+            category,
+            requiresResponse: true,
+            responseDeadline: priority === 'urgent'
+                ? new Date(Date.now() + 4 * 60 * 60 * 1000) // 4 hours for urgent
+                : new Date(Date.now() + 48 * 60 * 60 * 1000), // 48 hours for routine
+            status: 'unread'
+        };
+        const patientMessages = this.messages.get(patientId) || [];
+        patientMessages.push(message);
+        this.messages.set(patientId, patientMessages);
+        this.emit('message-sent', { patientId, messageId: id, category, priority });
+        return message;
+    }
+    /**
+     * Get messages for patient
+     */
+    getMessages(patientId, unreadOnly = false) {
+        const messages = this.messages.get(patientId) || [];
+        if (unreadOnly) {
+            return messages.filter(m => m.status === 'unread');
+        }
+        return messages.sort((a, b) => b.sentAt.getTime() - a.sentAt.getTime());
+    }
+    /**
+     * Mark message as read
+     */
+    markMessageRead(patientId, messageId) {
+        const messages = this.messages.get(patientId) || [];
+        const message = messages.find(m => m.id === messageId);
+        if (message) {
+            message.status = 'read';
+            message.readAt = new Date();
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // EDUCATIONAL CONTENT
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Get recommended educational content
+     */
+    getRecommendedContent(patientId) {
+        const summary = this.treatmentSummaries.get(patientId);
+        if (!summary) {
+            return Array.from(this.educationalContent.values()).slice(0, 5);
+        }
+        // Match content based on patient's diagnosis and treatment
+        const diagnosis = summary.diagnosis.condition.toLowerCase();
+        const treatment = summary.currentTreatment.regimen.toLowerCase();
+        const relevantContent = Array.from(this.educationalContent.values()).filter(content => {
+            const matchesCancer = content.cancerTypes?.some(ct => diagnosis.includes(ct.toLowerCase()));
+            const matchesTreatment = content.treatmentTypes?.some(tt => treatment.includes(tt.toLowerCase()));
+            return matchesCancer || matchesTreatment;
+        });
+        return relevantContent.slice(0, 10);
+    }
+    /**
+     * Search educational content
+     */
+    searchContent(query) {
+        const lowerQuery = query.toLowerCase();
+        return Array.from(this.educationalContent.values()).filter(content => content.title.toLowerCase().includes(lowerQuery) ||
+            content.description.toLowerCase().includes(lowerQuery) ||
+            content.topics.some(t => t.toLowerCase().includes(lowerQuery)));
+    }
+    initializeEducationalContent() {
+        const content = [
+            {
+                id: 'edu-1',
+                title: 'Understanding Your Cancer Treatment',
+                description: 'An overview of how cancer treatments work and what to expect.',
+                contentType: 'article',
+                targetAudience: ['new-patients', 'caregivers'],
+                topics: ['treatment', 'basics', 'getting-started'],
+                readingLevel: 'basic',
+                language: 'en',
+                content: '# Understanding Your Cancer Treatment\n\nThis guide explains the different types of cancer treatment...',
+                lastUpdated: new Date()
+            },
+            {
+                id: 'edu-2',
+                title: 'Managing Side Effects',
+                description: 'Tips for managing common side effects from cancer treatment.',
+                contentType: 'article',
+                targetAudience: ['patients', 'caregivers'],
+                topics: ['side-effects', 'self-care', 'management'],
+                readingLevel: 'basic',
+                language: 'en',
+                content: '# Managing Side Effects\n\nMany cancer treatments can cause side effects...',
+                lastUpdated: new Date()
+            },
+            {
+                id: 'edu-3',
+                title: 'What is Immunotherapy?',
+                description: 'Learn how immunotherapy helps your immune system fight cancer.',
+                contentType: 'video',
+                targetAudience: ['patients'],
+                treatmentTypes: ['immunotherapy'],
+                topics: ['immunotherapy', 'treatment-types'],
+                readingLevel: 'basic',
+                language: 'en',
+                content: '',
+                videoUrl: 'https://example.com/immunotherapy-video',
+                duration: 5,
+                lastUpdated: new Date()
+            },
+            {
+                id: 'edu-4',
+                title: 'Nutrition During Treatment',
+                description: 'Healthy eating tips while receiving cancer treatment.',
+                contentType: 'article',
+                targetAudience: ['patients', 'caregivers'],
+                topics: ['nutrition', 'self-care', 'wellness'],
+                readingLevel: 'basic',
+                language: 'en',
+                content: '# Nutrition During Treatment\n\nGood nutrition is important during cancer treatment...',
+                lastUpdated: new Date()
+            }
+        ];
+        for (const c of content) {
+            this.educationalContent.set(c.id, c);
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // APPOINTMENTS
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Request an appointment
+     */
+    async requestAppointment(request) {
+        const id = `APT-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+        const fullRequest = {
+            ...request,
+            id,
+            status: 'pending',
+            submittedAt: new Date()
+        };
+        const patientRequests = this.appointmentRequests.get(request.patientId) || [];
+        patientRequests.push(fullRequest);
+        this.appointmentRequests.set(request.patientId, patientRequests);
+        this.emit('appointment-requested', {
+            patientId: request.patientId,
+            requestId: id,
+            type: request.appointmentType,
+            urgency: request.urgency
+        });
+        return id;
+    }
+    /**
+     * Get appointment requests for patient
+     */
+    getAppointmentRequests(patientId) {
+        return this.appointmentRequests.get(patientId) || [];
+    }
+    /**
+     * Get dashboard data for patient
+     */
+    getDashboard(patientId) {
+        const summary = this.getTreatmentSummary(patientId);
+        const recentSymptoms = this.getSymptomHistory(patientId, 7);
+        const adherence = this.getAdherenceSummary(patientId);
+        const messages = this.getMessages(patientId, true);
+        const content = this.getRecommendedContent(patientId);
+        const alerts = [];
+        // Check for concerning symptoms
+        const latestSymptom = recentSymptoms[recentSymptoms.length - 1];
+        if (latestSymptom?.requiresFollowUp) {
+            alerts.push('Please contact your care team about your recent symptoms');
+        }
+        // Check adherence
+        if (adherence.overallAdherence < 80) {
+            alerts.push('Your medication adherence has been below target - remember to take medications as prescribed');
+        }
+        // Check unread messages
+        if (messages.length > 0) {
+            alerts.push(`You have ${messages.length} unread message(s) from your care team`);
+        }
+        return {
+            summary,
+            recentSymptoms: recentSymptoms.slice(-5),
+            adherence,
+            unreadMessages: messages.length,
+            upcomingAppointments: summary?.upcomingAppointments || [],
+            recommendedContent: content.slice(0, 3),
+            alerts
+        };
+    }
+}
+export default PatientPortalService;
+//# sourceMappingURL=patientPortal.js.map