16 |
61 | );
62 | }
--------------------------------------------------------------------------------
/components/icons/DocPill.js:
--------------------------------------------------------------------------------
1 | const DocPill = ({ className = "w-8 h-8", ...props }) => (
2 |
20 | );
21 |
22 | export default DocPill;
--------------------------------------------------------------------------------
/app/api/auth/send-otp/route.js:
--------------------------------------------------------------------------------
1 | import { NextResponse } from 'next/server';
2 | import { Redis } from '@upstash/redis';
3 |
4 | const redis = new Redis({
5 | url: process.env.UPSTASH_REDIS_REST_URL,
6 | token: process.env.UPSTASH_REDIS_REST_TOKEN,
7 | });
8 |
9 | const OTP_ATTEMPT_LIMIT = 5;
10 | const OTP_ATTEMPT_WINDOW = 15 * 60; // 15 minutes
11 | const OTP_LOCKOUT_TIME = 30 * 60; // 30 minutes
12 | const OTP_VERIFY_ATTEMPT_LIMIT = 5;
13 | const OTP_VERIFY_LOCKOUT_TIME = 30 * 60; // 30 minutes
14 |
15 | async function checkOtpRateLimit(email, ip) {
16 | const key = `otp:attempts:${email}:${ip}`;
17 | const lockKey = `otp:lockout:${email}:${ip}`;
18 | const locked = await redis.get(lockKey);
19 | if (locked) return { locked: true };
20 |
21 | let attempts = await redis.get(key);
22 | attempts = attempts ? parseInt(attempts) : 0;
23 | if (attempts >= OTP_ATTEMPT_LIMIT) {
24 | await redis.set(lockKey, '1', { ex: OTP_LOCKOUT_TIME });
25 | return { locked: true };
26 | }
27 | return { locked: false, attempts, key, lockKey };
28 | }
29 |
30 | // Add brute force protection for OTP verification
31 | export async function verifyOtpHandler(email, otp) {
32 | const verifyKey = `otp:verify:attempts:${email}`;
33 | const verifyLockKey = `otp:verify:lockout:${email}`;
34 | const locked = await redis.get(verifyLockKey);
35 | if (locked) return { locked: true };
36 |
37 | let attempts = await redis.get(verifyKey);
38 | attempts = attempts ? parseInt(attempts) : 0;
39 | if (attempts >= OTP_VERIFY_ATTEMPT_LIMIT) {
40 | await redis.set(verifyLockKey, '1', { ex: OTP_VERIFY_LOCKOUT_TIME });
41 | return { locked: true };
42 | }
43 | return { locked: false, attempts, verifyKey, verifyLockKey };
44 | }
45 |
46 | export async function incrementOtpVerifyAttempts(verifyKey) {
47 | await redis.incr(verifyKey);
48 | await redis.expire(verifyKey, OTP_ATTEMPT_WINDOW);
49 | }
50 |
51 | export async function resetOtpVerifyAttempts(verifyKey, verifyLockKey) {
52 | await redis.del(verifyKey);
53 | await redis.del(verifyLockKey);
54 | }
55 |
56 | async function incrementOtpAttempts(key) {
57 | await redis.incr(key);
58 | await redis.expire(key, OTP_ATTEMPT_WINDOW);
59 | }
60 |
61 | async function resetOtpAttempts(key, lockKey) {
62 | await redis.del(key);
63 | await redis.del(lockKey);
64 | }
65 |
66 | export async function POST(request) {
67 | // Redirect HTTP to HTTPS (only in production)
68 | if (process.env.NODE_ENV === 'production' && request.headers.get('x-forwarded-proto') === 'http') {
69 | return NextResponse.redirect(`https://${request.headers.get('host')}${request.url}`, 308);
70 | }
71 |
72 | return new Response(JSON.stringify({
73 | success: false,
74 | error: 'This endpoint is deprecated. Please use NextAuth authentication.'
75 | }), {
76 | status: 410,
77 | headers: { 'Content-Type': 'application/json' }
78 | });
79 | }
80 |
81 |
--------------------------------------------------------------------------------
/app/api/prescriptions/route.js:
--------------------------------------------------------------------------------
1 | import { databaseService } from '../../../services/databaseService';
2 | import { NextResponse } from 'next/server';
3 |
4 | /**
5 | * GET /api/prescriptions - Fetch all prescriptions
6 | */
7 | export async function GET(request) {
8 | try {
9 | const doctorId = request.headers.get('X-Doctor-ID');
10 |
11 | if (!doctorId || doctorId === 'default-doctor') {
12 | return NextResponse.json(
13 | { success: false, error: 'Invalid doctor context', data: [] },
14 | { status: 403 }
15 | );
16 | }
17 |
18 | const url = new URL(request.url);
19 | const patientId = url.searchParams.get('patientId');
20 | let prescriptions;
21 |
22 | if (patientId) {
23 | // Fetch prescriptions for a specific patient
24 | prescriptions = await databaseService.getPrescriptionsByPatient(patientId, doctorId);
25 | } else {
26 | // Fetch all prescriptions
27 | prescriptions = await databaseService.getPrescriptions(doctorId);
28 | }
29 |
30 | return NextResponse.json({ success: true, data: prescriptions || [] });
31 | } catch (error) {
32 | console.error('API Error fetching prescriptions:', error);
33 | return NextResponse.json(
34 | { success: false, error: 'Failed to fetch prescriptions', data: [] },
35 | { status: 500 }
36 | );
37 | }
38 | }
39 |
40 | /**
41 | * POST /api/prescriptions - Save prescriptions
42 | */
43 | export async function POST(request) {
44 | try {
45 | const doctorId = request.headers.get('X-Doctor-ID');
46 |
47 | if (!doctorId || doctorId === 'default-doctor') {
48 | return NextResponse.json(
49 | { success: false, error: 'Invalid doctor context' },
50 | { status: 403 }
51 | );
52 | }
53 |
54 | const body = await request.json();
55 |
56 | if (body.prescriptions) {
57 | // Save multiple prescriptions
58 | const success = await databaseService.savePrescriptions(body.prescriptions, doctorId);
59 |
60 | if (success) {
61 | return NextResponse.json({ success: true });
62 | } else {
63 | return NextResponse.json(
64 | { success: false, error: 'Failed to save prescriptions' },
65 | { status: 500 }
66 | );
67 | }
68 | } else if (body.prescription) {
69 | // Save single prescription
70 | const savedPrescription = await databaseService.savePrescription(body.prescription, doctorId);
71 |
72 | if (savedPrescription) {
73 | return NextResponse.json({ success: true, data: savedPrescription });
74 | } else {
75 | return NextResponse.json(
76 | { success: false, error: 'Failed to save prescription' },
77 | { status: 500 }
78 | );
79 | }
80 | } else {
81 | return NextResponse.json(
82 | { success: false, error: 'Invalid request body' },
83 | { status: 400 }
84 | );
85 | }
86 | } catch (error) {
87 | console.error('API Error saving prescriptions:', error);
88 | return NextResponse.json(
89 | { success: false, error: 'Failed to save prescriptions' },
90 | { status: 500 }
91 | );
92 | }
93 | }
--------------------------------------------------------------------------------
/utils/imageUtils.js:
--------------------------------------------------------------------------------
1 | // Image format detection and browser support utilities
2 |
3 | export const detectImageFormat = (src) => {
4 | if (!src) return 'Unknown';
5 |
6 | if (src.includes('.avif')) return 'AVIF';
7 | if (src.includes('.webp')) return 'WebP';
8 | if (src.includes('.jpg') || src.includes('.jpeg')) return 'JPEG';
9 | if (src.includes('.png')) return 'PNG';
10 | if (src.includes('.svg')) return 'SVG';
11 |
12 | return 'Unknown';
13 | };
14 |
15 | export const getBrowserImageSupport = () => {
16 | if (typeof window === 'undefined') {
17 | return { avif: false, webp: false };
18 | }
19 |
20 | const supportsWebP = () => {
21 | try {
22 | const canvas = document.createElement('canvas');
23 | canvas.width = 1;
24 | canvas.height = 1;
25 | return canvas.toDataURL('image/webp').indexOf('data:image/webp') === 0;
26 | } catch (e) {
27 | return false;
28 | }
29 | };
30 |
31 | const supportsAVIF = () => {
32 | try {
33 | const canvas = document.createElement('canvas');
34 | canvas.width = 1;
35 | canvas.height = 1;
36 | return canvas.toDataURL('image/avif').indexOf('data:image/avif') === 0;
37 | } catch (e) {
38 | return false;
39 | }
40 | };
41 |
42 | return {
43 | avif: supportsAVIF(),
44 | webp: supportsWebP()
45 | };
46 | };
47 |
48 | export const getCompressionSavings = (format) => {
49 | switch (format?.toUpperCase()) {
50 | case 'AVIF':
51 | return '~50% vs PNG';
52 | case 'WEBP':
53 | return '~25% vs PNG';
54 | case 'JPEG':
55 | return '~10% vs PNG';
56 | default:
57 | return 'No compression';
58 | }
59 | };
60 |
61 | export const logImageLoad = (format, src, additionalInfo = {}) => {
62 | const browserSupport = getBrowserImageSupport();
63 |
64 | // console.log(`✅ Image loaded successfully:`, {
65 | // format: format?.toUpperCase(),
66 | // src,
67 | // browserSupport: {
68 | // AVIF: browserSupport.avif,
69 | // WebP: browserSupport.webp
70 | // },
71 | // compressionSavings: getCompressionSavings(format),
72 | // userAgent: typeof navigator !== 'undefined' ? navigator.userAgent.split(' ').pop() : 'Unknown',
73 | // ...additionalInfo
74 | // });
75 | };
76 |
77 | export const logImageError = (format, src, additionalInfo = {}) => {
78 | console.warn(`❌ Image failed to load:`, {
79 | format: format?.toUpperCase(),
80 | src,
81 | ...additionalInfo
82 | });
83 | };
84 |
85 | // Get the best image format for the current browser
86 | export const getBestImageFormat = (baseName, supportedFormats = ['avif', 'webp', 'jpg', 'png']) => {
87 | const browserSupport = getBrowserImageSupport();
88 |
89 | if (supportedFormats.includes('avif') && browserSupport.avif) {
90 | return `${baseName}.avif`;
91 | }
92 |
93 | if (supportedFormats.includes('webp') && browserSupport.webp) {
94 | return `${baseName}.webp`;
95 | }
96 |
97 | if (supportedFormats.includes('jpg')) {
98 | return `${baseName}.jpg`;
99 | }
100 |
101 | return `${baseName}.png`;
102 | };
--------------------------------------------------------------------------------
/components/TitleManager.js:
--------------------------------------------------------------------------------
1 | 'use client';
2 |
3 | import { useEffect } from 'react';
4 | import { useSession } from 'next-auth/react';
5 | import { usePathname } from 'next/navigation';
6 | import { storage } from '../utils/storage';
7 |
8 | export default function TitleManager() {
9 | const { data: session } = useSession();
10 | const pathname = usePathname();
11 |
12 | useEffect(() => {
13 | const updateTitleFromPath = async () => {
14 | // Only update title if no specific component has set it
15 | const currentTitle = document.title;
16 |
17 | // If the title has already been set by a component, don't override it
18 | if (currentTitle !== 'Doc Prescrip' && !currentTitle.includes('Doc Prescrip')) {
19 | return;
20 | }
21 |
22 | let pageTitle = '';
23 |
24 | // Determine page title from pathname
25 | switch (pathname) {
26 | case '/':
27 | pageTitle = 'Dashboard';
28 | break;
29 | case '/login':
30 | pageTitle = 'Login';
31 | break;
32 | case '/privacy':
33 | pageTitle = 'Privacy Policy';
34 | break;
35 | case '/terms':
36 | pageTitle = 'Terms of Service';
37 | break;
38 | case '/404':
39 | case '/not-found':
40 | pageTitle = 'Page Not Found';
41 | break;
42 | default:
43 | // For dynamic routes or other pages, extract from pathname
44 | if (pathname.includes('/patient/')) {
45 | pageTitle = 'Patient Details';
46 | } else if (pathname.includes('/billing')) {
47 | pageTitle = 'Billing';
48 | } else if (pathname.includes('/templates')) {
49 | pageTitle = 'Templates';
50 | } else if (pathname.includes('/settings')) {
51 | pageTitle = 'Settings';
52 | } else pageTitle = 'Page Not Found';
53 | break;
54 | }
55 |
56 | // Get doctor information if user is logged in
57 | let doctorName = '';
58 | if (session?.user) {
59 | try {
60 | const doctorContext = storage.getDoctorContext();
61 | if (doctorContext?.lastName) {
62 | doctorName = `Dr. ${doctorContext.lastName}`;
63 | }
64 | } catch (error) {
65 | console.error('Error fetching doctor context for title:', error);
66 | }
67 | }
68 |
69 | // Build title
70 | let title = '';
71 | if (pageTitle) {
72 | if (doctorName) {
73 | title = `${pageTitle} | ${doctorName} | Doc Prescrip`;
74 | } else {
75 | title = `${pageTitle} | Doc Prescrip`;
76 | }
77 | } else {
78 | if (doctorName) {
79 | title = `${doctorName} | Doc Prescrip`;
80 | } else {
81 | title = 'Doc Prescrip';
82 | }
83 | }
84 |
85 | document.title = title;
86 | };
87 |
88 | // Small delay to allow components to set their own titles first
89 | const timeoutId = setTimeout(updateTitleFromPath, 100);
90 |
91 | return () => clearTimeout(timeoutId);
92 | }, [pathname, session]);
93 |
94 | return null; // This component doesn't render anything
95 | }
--------------------------------------------------------------------------------
/app/api/doctor/profile/route.js:
--------------------------------------------------------------------------------
1 | import { doctorService } from '../../../../services/doctorService.js';
2 |
3 | export async function GET(request) {
4 | try {
5 | const doctorId = request.headers.get('x-doctor-id') || new URL(request.url).searchParams.get('doctorId');
6 |
7 | if (!doctorId) {
8 | return Response.json({ error: 'Doctor ID is required' }, { status: 400 });
9 | }
10 |
11 | // Get doctor profile
12 | const doctor = await doctorService.getDoctorById(doctorId);
13 |
14 | if (!doctor) {
15 | return Response.json({ error: 'Doctor not found' }, { status: 404 });
16 | }
17 |
18 | // Return doctor profile data
19 | const profileData = {
20 | name: doctor.name,
21 | specialization: doctor.specialization,
22 | degree: doctor.degree,
23 | registrationNumber: doctor.registrationNumber,
24 | hospitalName: doctor.hospitalName,
25 | hospitalAddress: doctor.hospitalAddress,
26 | phone: doctor.phone,
27 | email: doctor.email
28 | };
29 |
30 | return Response.json({
31 | success: true,
32 | data: profileData
33 | });
34 |
35 | } catch (error) {
36 | console.error('Error handling doctor profile GET request:', error);
37 | return Response.json({ error: 'Internal server error' }, { status: 500 });
38 | }
39 | }
40 |
41 | export async function PUT(request) {
42 | try {
43 | const doctorId = request.headers.get('x-doctor-id');
44 |
45 | if (!doctorId) {
46 | return Response.json({ error: 'Doctor ID is required' }, { status: 400 });
47 | }
48 |
49 | const body = await request.json();
50 | const {
51 | name,
52 | specialization,
53 | degree,
54 | registrationNumber,
55 | hospitalName,
56 | hospitalAddress,
57 | phone,
58 | email
59 | } = body;
60 |
61 | // Validate required fields
62 | if (!name) {
63 | return Response.json({ error: 'Name is required' }, { status: 400 });
64 | }
65 |
66 | // Prepare update data
67 | const updateData = {
68 | name,
69 | specialization,
70 | degree,
71 | registrationNumber,
72 | hospitalName,
73 | hospitalAddress,
74 | phone,
75 | email
76 | };
77 |
78 | // Remove empty/undefined fields to avoid overwriting with blank values
79 | Object.keys(updateData).forEach(key => {
80 | if (updateData[key] === undefined || updateData[key] === null) {
81 | delete updateData[key];
82 | }
83 | });
84 |
85 | // Update doctor profile
86 | const success = await doctorService.updateDoctorProfile(doctorId, updateData);
87 |
88 | if (success) {
89 | return Response.json({
90 | success: true,
91 | message: 'Doctor profile updated successfully',
92 | data: updateData
93 | });
94 | } else {
95 | return Response.json({ error: 'Failed to update doctor profile' }, { status: 500 });
96 | }
97 |
98 | } catch (error) {
99 | console.error('Error handling doctor profile PUT request:', error);
100 | return Response.json({ error: 'Internal server error' }, { status: 500 });
101 | }
102 | }
--------------------------------------------------------------------------------
/components/PlaceholderImageWithLogo.js:
--------------------------------------------------------------------------------
1 | 'use client';
2 |
3 | import { Stethoscope } from 'lucide-react';
4 | import { useEffect, useState } from 'react';
5 | import { detectImageFormat, logImageLoad, logImageError, getBrowserImageSupport } from '../utils/imageUtils';
6 |
7 | export default function PlaceholderImageWithLogo({ isDarkTheme, themeInitialized }) {
8 | const [loadedImageFormat, setLoadedImageFormat] = useState(null);
9 |
10 | const handleImageLoad = (event) => {
11 | const src = event.target.currentSrc || event.target.src;
12 | const format = detectImageFormat(src);
13 | setLoadedImageFormat(format);
14 |
15 | logImageLoad(format, src, {
16 | component: 'PlaceholderImageWithLogo',
17 | theme: isDarkTheme ? 'Dark' : 'Light'
18 | });
19 | };
20 |
21 | const handleImageError = (event) => {
22 | const src = event.target.src;
23 | const format = detectImageFormat(src);
24 |
25 | logImageError(format, src, {
26 | component: 'PlaceholderImageWithLogo',
27 | fallbackNote: 'Will fall back to next source format'
28 | });
29 | };
30 |
31 | useEffect(() => {
32 | if (themeInitialized) {
33 | const browserSupport = getBrowserImageSupport();
34 | // console.log('🎨 PlaceholderImage - Theme initialized:', {
35 | // theme: isDarkTheme ? 'Dark' : 'Light',
36 | // browserSupport
37 | // });
38 | }
39 | }, [themeInitialized, isDarkTheme]);
40 |
41 | return (
42 |
17 |
60 |
18 |
37 |
38 |
19 |
20 | 
28 |
29 |
30 | 
28 | 31 | 404 Not Found 32 |
33 |34 | maybe the diagnosis was wrong, doc 35 |
36 |
39 |
59 |
40 |
46 | |
47 |
51 | Return to Dashboard
52 |
53 |
54 |
55 |
58 | The page you're looking for doesn't exist.
56 |Please check the URL or navigate back to continue.
57 |
43 | {/* Background Image */}
44 | {themeInitialized && (
45 |
46 | {/* AVIF - Best compression, modern browsers */}
47 | 
65 |
66 | )}
67 | {!themeInitialized && (
68 |
69 | )}
70 |
71 | {/* Development indicator for loaded image format */}
72 | {process.env.NODE_ENV === 'development' && loadedImageFormat && (
73 |
84 | );
85 | }
86 |
--------------------------------------------------------------------------------
/app/api/custom-data/[type]/route.js:
--------------------------------------------------------------------------------
1 | import { databaseService } from '../../../../services/databaseService';
2 | import { NextResponse } from 'next/server';
3 |
4 | export async function GET(request, { params }) {
5 | try {
6 | const { type } = await params;
7 |
8 | // Get doctor ID from headers (set by frontend apiCall function)
9 | const doctorId = request.headers.get('X-Doctor-ID');
10 |
11 | if (!doctorId || doctorId === 'default-doctor') {
12 | return NextResponse.json(
13 | { success: false, error: 'Invalid doctor context' },
14 | { status: 401 }
15 | );
16 | }
17 |
18 | let data;
19 | switch (type) {
20 | case 'symptoms':
21 | data = await databaseService.getCustomSymptoms(doctorId);
22 | break;
23 | case 'diagnoses':
24 | data = await databaseService.getCustomDiagnoses(doctorId);
25 | break;
26 | case 'lab-tests':
27 | data = await databaseService.getCustomLabTests(doctorId);
28 | break;
29 | case 'medications':
30 | data = await databaseService.getCustomMedications(doctorId);
31 | break;
32 | default:
33 | return NextResponse.json(
34 | { success: false, error: 'Invalid custom data type' },
35 | { status: 400 }
36 | );
37 | }
38 |
39 | return NextResponse.json({ success: true, data });
40 | } catch (error) {
41 | console.error(`API Error fetching custom ${type}:`, error);
42 | return NextResponse.json(
43 | { success: false, error: `Failed to fetch custom ${type}` },
44 | { status: 500 }
45 | );
46 | }
47 | }
48 |
49 | export async function POST(request, { params }) {
50 | try {
51 | const { type } = await params;
52 | const { items } = await request.json();
53 |
54 | // Get doctor ID from headers (set by frontend apiCall function)
55 | const doctorId = request.headers.get('X-Doctor-ID');
56 |
57 | if (!doctorId || doctorId === 'default-doctor') {
58 | return NextResponse.json(
59 | { success: false, error: 'Invalid doctor context' },
60 | { status: 401 }
61 | );
62 | }
63 |
64 | let success;
65 | switch (type) {
66 | case 'symptoms':
67 | success = await databaseService.saveCustomSymptoms(items, doctorId);
68 | break;
69 | case 'diagnoses':
70 | success = await databaseService.saveCustomDiagnoses(items, doctorId);
71 | break;
72 | case 'lab-tests':
73 | success = await databaseService.saveCustomLabTests(items, doctorId);
74 | break;
75 | case 'medications':
76 | success = await databaseService.saveCustomMedications(items, doctorId);
77 | break;
78 | default:
79 | return NextResponse.json(
80 | { success: false, error: 'Invalid custom data type' },
81 | { status: 400 }
82 | );
83 | }
84 |
85 | if (success) {
86 | return NextResponse.json({ success: true });
87 | } else {
88 | return NextResponse.json(
89 | { success: false, error: `Failed to save custom ${type}` },
90 | { status: 500 }
91 | );
92 | }
93 | } catch (error) {
94 | console.error(`API Error saving custom ${type}:`, error);
95 | return NextResponse.json(
96 | { success: false, error: `Failed to save custom ${type}` },
97 | { status: 500 }
98 | );
99 | }
100 | }
--------------------------------------------------------------------------------
/app/api/logout/route.js:
--------------------------------------------------------------------------------
1 | import { NextResponse } from 'next/server';
2 | import { getToken } from 'next-auth/jwt';
3 | import { Redis } from '@upstash/redis';
4 | import { jwtVerify } from 'jose';
5 |
6 | const redis = new Redis({
7 | url: process.env.UPSTASH_REDIS_REST_URL,
8 | token: process.env.UPSTASH_REDIS_REST_TOKEN,
9 | });
10 |
11 | const secret = new TextEncoder().encode(process.env.JWT_SECRET || 'default_jwt_secret');
12 |
13 | async function verifyJwt(token) {
14 | try {
15 | const { payload } = await jwtVerify(token, secret);
16 | return payload;
17 | } catch (err) {
18 | return null;
19 | }
20 | }
21 |
22 | export async function POST(request) {
23 | try {
24 | // Check if user has NextAuth session (Google OAuth)
25 | const token = await getToken({ req: request, secret: process.env.NEXTAUTH_SECRET });
26 |
27 | // Check for custom JWT auth
28 | let doctorId = null;
29 | const doctorAuthCookie = request.cookies.get('doctor-auth');
30 | const refreshCookie = request.cookies.get('doctor-refresh');
31 |
32 | if (doctorAuthCookie?.value) {
33 | const decoded = await verifyJwt(doctorAuthCookie.value);
34 | if (decoded?.doctorId) {
35 | doctorId = decoded.doctorId;
36 | }
37 | }
38 |
39 | const response = NextResponse.json({
40 | success: true,
41 | hasNextAuthSession: !!token
42 | });
43 |
44 | // Clear custom JWT authentication cookies
45 | response.cookies.set('pin-auth', '', {
46 | httpOnly: true,
47 | secure: process.env.NODE_ENV === 'production',
48 | sameSite: 'lax',
49 | expires: new Date(0),
50 | path: '/'
51 | });
52 |
53 | response.cookies.set('doctor-auth', '', {
54 | httpOnly: true,
55 | secure: process.env.NODE_ENV === 'production',
56 | sameSite: 'lax',
57 | expires: new Date(0),
58 | path: '/'
59 | });
60 |
61 | response.cookies.set('doctor-refresh', '', {
62 | httpOnly: true,
63 | secure: process.env.NODE_ENV === 'production',
64 | sameSite: 'lax',
65 | expires: new Date(0),
66 | path: '/'
67 | });
68 |
69 | // Clean up refresh tokens from Redis if we have a doctor ID
70 | if (doctorId && refreshCookie?.value) {
71 | try {
72 | await redis.del(`refresh:${doctorId}:${refreshCookie.value}`);
73 | } catch (error) {
74 | console.error('Error cleaning up refresh token:', error);
75 | }
76 | }
77 |
78 | // Clear NextAuth session cookies if they exist
79 | if (token) {
80 | // Clear NextAuth session cookies with proper naming
81 | const isProduction = process.env.NODE_ENV === 'production';
82 | const cookiePrefix = isProduction ? '__Secure-' : '';
83 |
84 | response.cookies.set(`${cookiePrefix}next-auth.session-token`, '', {
85 | httpOnly: true,
86 | secure: isProduction,
87 | sameSite: 'lax',
88 | expires: new Date(0),
89 | path: '/'
90 | });
91 |
92 | response.cookies.set(`${cookiePrefix}next-auth.csrf-token`, '', {
93 | httpOnly: true,
94 | secure: isProduction,
95 | sameSite: 'lax',
96 | expires: new Date(0),
97 | path: '/'
98 | });
99 |
100 | response.cookies.set(`${cookiePrefix}next-auth.callback-url`, '', {
101 | httpOnly: true,
102 | secure: isProduction,
103 | sameSite: 'lax',
104 | expires: new Date(0),
105 | path: '/'
106 | });
107 | }
108 |
109 | return response;
110 | } catch (error) {
111 | console.error('Logout error:', error);
112 | return NextResponse.json(
113 | { success: false, error: 'Server error' },
114 | { status: 500 }
115 | );
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/components/ConfirmationDialog.js:
--------------------------------------------------------------------------------
1 | 'use client';
2 |
3 | import { X, Loader2 } from 'lucide-react';
4 | import { useState } from 'react';
5 |
6 | export default function ConfirmationDialog({
7 | isOpen,
8 | title,
9 | message,
10 | onConfirm,
11 | onCancel,
12 | isLoading = false,
13 | requireConfirmation = false,
14 | confirmationText = '',
15 | confirmationPlaceholder = 'Type to confirm'
16 | }) {
17 | const [inputValue, setInputValue] = useState('');
18 |
19 | if (!isOpen) return null;
20 |
21 | const canConfirm = !requireConfirmation || inputValue.trim() === confirmationText.trim();
22 |
23 | const handleConfirm = () => {
24 | if (canConfirm) {
25 | onConfirm();
26 | }
27 | };
28 |
29 | const handleCancel = () => {
30 | setInputValue('');
31 | onCancel();
32 | };
33 |
34 | return (
35 |
77 | {loadedImageFormat}
78 |
79 | )}
80 |
81 | {/* Optional gradient overlay for better text readability */}
82 |
83 |
36 |
95 | );
96 | }
97 |
--------------------------------------------------------------------------------
/lib/medicalData.js:
--------------------------------------------------------------------------------
1 | export const PREDEFINED_SYMPTOMS = [
2 | 'Fever', 'Headache', 'Cough', 'Sore Throat', 'Runny Nose', 'Body Ache', 'Fatigue', 'Nausea', 'Vomiting', 'Diarrhea',
3 | 'Stomach Pain', 'Chest Pain', 'Shortness of Breath', 'Dizziness', 'Back Pain', 'Joint Pain', 'Muscle Pain', 'Skin Rash',
4 | 'Itching', 'Swelling', 'Constipation', 'Loss of Appetite', 'Weight Loss', 'Weight Gain', 'Sleep Problems', 'Anxiety',
5 | 'Depression', 'Confusion', 'Memory Loss', 'Blurred Vision', 'Ear Pain', 'Hearing Loss', 'Nose Bleeding', 'Sneezing',
6 | 'Wheezing', 'Hiccups', 'Sweating', 'Chills', 'Weakness', 'Numbness', 'Tingling', 'Bleeding', 'Bruising', 'Pale Skin',
7 | 'Yellow Skin', 'Dark Urine', 'Frequent Urination', 'Painful Urination', 'Blood in Urine', 'Irregular Heartbeat',
8 | 'High Blood Pressure', 'Low Blood Pressure', 'Leg Cramps', 'Foot Swelling', 'Hand Swelling'
9 | ];
10 |
11 | export const PREDEFINED_DIAGNOSES = [
12 | 'Common Cold', 'Flu', 'Viral Fever', 'Bacterial Infection', 'Urinary Tract Infection', 'Pneumonia', 'Bronchitis',
13 | 'Asthma', 'Allergic Rhinitis', 'Sinusitis', 'Pharyngitis', 'Tonsillitis', 'Gastritis', 'Acid Reflux', 'IBS',
14 | 'Food Poisoning', 'Migraine', 'Tension Headache', 'Hypertension', 'Diabetes Type 2', 'Diabetes Type 1',
15 | 'Hypothyroidism', 'Hyperthyroidism', 'Anemia', 'Vitamin D Deficiency', 'Vitamin B12 Deficiency', 'Arthritis',
16 | 'Osteoporosis', 'Fibromyalgia', 'Sciatica', 'Disc Prolapse', 'Cervical Spondylosis', 'Lumbar Spondylosis',
17 | 'Frozen Shoulder', 'Tennis Elbow', 'Carpal Tunnel Syndrome', 'Varicose Veins', 'Deep Vein Thrombosis',
18 | 'Heart Disease', 'Arrhythmia', 'Angina', 'Heart Attack', 'Stroke', 'High Cholesterol', 'Kidney Stones',
19 | 'Gallstones', 'Liver Disease', 'Hepatitis', 'Pancreatitis', 'Appendicitis', 'Hernia', 'Hemorrhoids',
20 | 'Skin Infection', 'Eczema', 'Psoriasis', 'Acne', 'Fungal Infection', 'Depression', 'Anxiety Disorder',
21 | 'Insomnia', 'Sleep Apnea', 'ADHD', 'Bipolar Disorder', 'Schizophrenia', 'Dementia', 'Alzheimer Disease',
22 | 'Parkinson Disease', 'Epilepsy', 'Multiple Sclerosis', 'Glaucoma', 'Cataract', 'Macular Degeneration',
23 | 'Hearing Loss', 'Tinnitus', 'Vertigo', 'Meniere Disease', 'COPD', 'Tuberculosis', 'Cancer', 'Leukemia',
24 | 'Lymphoma', 'Osteoarthritis', 'Rheumatoid Arthritis', 'Gout', 'Lupus', 'Celiac Disease', 'Crohn Disease',
25 | 'Ulcerative Colitis', 'Endometriosis', 'PCOS', 'Menopause', 'Erectile Dysfunction', 'Prostate Enlargement'
26 | ];
27 |
28 | export const PREDEFINED_LAB_TESTS = [
29 | 'Complete Blood Count (CBC)', 'Blood Sugar Fasting', 'Blood Sugar Random', 'HbA1c', 'Lipid Profile', 'Liver Function Test',
30 | 'Kidney Function Test', 'Thyroid Function Test', 'Urine Routine', 'ECG', 'Chest X-Ray', 'Blood Pressure',
31 | 'Hemoglobin', 'ESR', 'CRP', 'Vitamin D', 'Vitamin B12', 'Iron Studies', 'Calcium', 'Phosphorus',
32 | 'Uric Acid', 'Creatinine', 'Blood Urea', 'SGPT/ALT', 'SGOT/AST', 'Bilirubin Total', 'Bilirubin Direct',
33 | 'Alkaline Phosphatase', 'Protein Total', 'Albumin', 'Globulin', 'TSH', 'T3', 'T4', 'Free T3', 'Free T4',
34 | 'Total Cholesterol', 'HDL Cholesterol', 'LDL Cholesterol', 'Triglycerides', 'VLDL', 'Glucose Tolerance Test',
35 | 'HbsAg', 'Anti HCV', 'HIV', 'VDRL', 'Widal Test', 'Dengue NS1', 'Dengue IgM', 'Dengue IgG',
36 | 'Malaria Antigen', 'Typhoid IgM', 'Stool Routine', 'Stool Culture', 'Blood Culture', 'Urine Culture',
37 | 'Sputum AFB', 'Mantoux Test', 'Prothrombin Time', 'APTT', 'INR', 'D-Dimer', 'Troponin I', 'Troponin T',
38 | 'CPK-MB', 'LDH', 'Amylase', 'Lipase', 'PSA', 'CEA', 'CA 19-9', 'CA 125', 'AFP', 'Beta HCG',
39 | 'Prolactin', 'FSH', 'LH', 'Testosterone', 'Estradiol', 'Progesterone', 'Cortisol', 'Growth Hormone',
40 | 'Insulin', 'C-Peptide', 'Ferritin', 'TIBC', 'Transferrin Saturation', 'Folate', 'Homocysteine',
41 | 'Magnesium', 'Sodium', 'Potassium', 'Chloride', 'CO2', 'Anion Gap', 'Osmolality', 'Lactate',
42 | 'Ammonia', 'Ceruloplasmin', 'Alpha 1 Antitrypsin', 'Complement C3', 'Complement C4', 'ANA', 'Anti dsDNA',
43 | 'Rheumatoid Factor', 'Anti CCP', 'ASO Titre', 'C-Reactive Protein Quantitative'
44 | ];
--------------------------------------------------------------------------------
/app/api/auth/link-account/route.js:
--------------------------------------------------------------------------------
1 | import { NextResponse } from 'next/server';
2 | import { getToken } from 'next-auth/jwt';
3 | import clientPromise from '../../../../lib/mongodb';
4 | import bcrypt from 'bcryptjs';
5 |
6 | export async function POST(request) {
7 | try {
8 | // Get NextAuth token
9 | const token = await getToken({ req: request, secret: process.env.NEXTAUTH_SECRET });
10 |
11 | if (!token || !token.email) {
12 | return NextResponse.json(
13 | { success: false, error: 'Not authenticated' },
14 | { status: 401 }
15 | );
16 | }
17 |
18 | const { action, password } = await request.json();
19 |
20 | const client = await clientPromise;
21 | const db = client.db('doc-prescrip');
22 | const doctors = db.collection('doctors');
23 |
24 | const doctor = await doctors.findOne({ email: token.email });
25 |
26 | if (!doctor) {
27 | return NextResponse.json(
28 | { success: false, error: 'Doctor not found' },
29 | { status: 404 }
30 | );
31 | }
32 |
33 | if (action === 'link-google') {
34 | // User wants to link Google account to existing email/password account
35 | if (!doctor.passwordHash) {
36 | return NextResponse.json(
37 | { success: false, error: 'No password set for this account' },
38 | { status: 400 }
39 | );
40 | }
41 |
42 | // Check if user already has Google linked
43 | if (doctor.googleId) {
44 | return NextResponse.json(
45 | { success: false, error: 'Google account is already linked to this account' },
46 | { status: 400 }
47 | );
48 | }
49 |
50 | // Update doctor with Google information from token
51 | await doctors.updateOne(
52 | { email: token.email },
53 | {
54 | $set: {
55 | googleId: token.sub, // Google user ID from JWT token
56 | isGoogleUser: true,
57 | image: token.picture || doctor.image,
58 | updatedAt: new Date()
59 | }
60 | }
61 | );
62 |
63 | return NextResponse.json({
64 | success: true,
65 | message: 'Google account linked successfully'
66 | });
67 |
68 | } else if (action === 'set-password') {
69 | // Google user wants to set a password for email/password login
70 | if (!password || password.length < 8) {
71 | return NextResponse.json(
72 | { success: false, error: 'Password must be at least 8 characters long' },
73 | { status: 400 }
74 | );
75 | }
76 |
77 | // Validate password strength
78 | const strongPasswordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*()_\-+=\[\]{};':",.<>/?\\|`~]).{8,}$/;
79 | if (!strongPasswordRegex.test(password)) {
80 | return NextResponse.json(
81 | { success: false, error: 'Password must include uppercase, lowercase, number, and special character' },
82 | { status: 400 }
83 | );
84 | }
85 |
86 | // Hash the password
87 | const salt = await bcrypt.genSalt(10);
88 | const passwordHash = await bcrypt.hash(password, salt);
89 |
90 | // Update doctor with password
91 | await doctors.updateOne(
92 | { email: token.email },
93 | {
94 | $set: {
95 | passwordHash,
96 | updatedAt: new Date()
97 | }
98 | }
99 | );
100 |
101 | return NextResponse.json({
102 | success: true,
103 | message: 'Password set successfully. You can now login with email and password.'
104 | });
105 |
106 | } else {
107 | return NextResponse.json(
108 | { success: false, error: 'Invalid action' },
109 | { status: 400 }
110 | );
111 | }
112 |
113 | } catch (error) {
114 | console.error('Account linking error:', error);
115 | return NextResponse.json(
116 | { success: false, error: 'Internal server error' },
117 | { status: 500 }
118 | );
119 | }
120 | }
--------------------------------------------------------------------------------
/components/FluidToggle.js:
--------------------------------------------------------------------------------
1 | import React, { useState, useRef, useEffect } from 'react';
2 |
3 | export default function FluidToggle({
4 | checked = false,
5 | onChange,
6 | disabled = false,
7 | size = 'default',
8 | className = ''
9 | }) {
10 | const [isPressed, setIsPressed] = useState(false);
11 | const [isHovered, setIsHovered] = useState(false);
12 | const timeoutRef = useRef(null);
13 |
14 | // Memoized size configurations with smoother scaling
15 | const sizeConfig = {
16 | small: {
17 | track: 'w-10 h-5',
18 | thumb: 'w-3.5 h-3.5',
19 | thumbPressed: 'w-5 h-3.5',
20 | thumbHovered: 'w-4 h-4',
21 | translateUnchecked: 'translate-x-0.5',
22 | translateChecked: 'translate-x-[1.25rem]',
23 | translateCheckedPressed: 'translate-x-[0.75rem]'
24 | },
25 | default: {
26 | track: 'w-10 h-6',
27 | thumb: 'w-4 h-4',
28 | thumbPressed: 'w-6 h-4',
29 | thumbHovered: 'w-4 h-4',
30 | translateUnchecked: 'translate-x-1',
31 | translateChecked: 'translate-x-[1.3rem]',
32 | translateCheckedPressed: 'translate-x-[0.85rem]'
33 | },
34 | large: {
35 | track: 'w-14 h-7',
36 | thumb: 'w-5 h-5',
37 | thumbPressed: 'w-7 h-5',
38 | thumbHovered: 'w-6 h-6',
39 | translateUnchecked: 'translate-x-1',
40 | translateChecked: 'translate-x-[2.25rem]',
41 | translateCheckedPressed: 'translate-x-[1.75rem]'
42 | }
43 | };
44 |
45 | const config = sizeConfig[size];
46 |
47 | const handleMouseDown = () => {
48 | if (disabled) return;
49 | setIsPressed(true);
50 |
51 | if (timeoutRef.current) {
52 | clearTimeout(timeoutRef.current);
53 | timeoutRef.current = null;
54 | }
55 | };
56 |
57 | const handleMouseUp = () => {
58 | if (disabled || !isPressed) return;
59 |
60 | onChange && onChange(!checked);
61 |
62 | timeoutRef.current = setTimeout(() => {
63 | setIsPressed(false);
64 | timeoutRef.current = null;
65 | }, 80);
66 | };
67 |
68 | const handleMouseEnter = () => {
69 | if (!disabled) setIsHovered(true);
70 | };
71 |
72 | const handleMouseLeave = () => {
73 | setIsHovered(false);
74 | if (isPressed) {
75 | handleMouseUp();
76 | }
77 | };
78 |
79 | useEffect(() => {
80 | return () => {
81 | if (timeoutRef.current) {
82 | clearTimeout(timeoutRef.current);
83 | }
84 | };
85 | }, []);
86 |
87 | // Pre-calculate thumb classes with smooth transitions
88 | let thumbClasses = 'inline-block rounded-full bg-white dark:bg-gray-900 shadow-lg transition-all duration-150 ease-out transform ';
89 |
90 | if (isPressed) {
91 | thumbClasses += config.thumbPressed + ' ';
92 | } else if (isHovered) {
93 | thumbClasses += config.thumbHovered + ' ';
94 | } else {
95 | thumbClasses += config.thumb + ' ';
96 | }
97 |
98 | if (checked) {
99 | if (isPressed) {
100 | thumbClasses += config.translateCheckedPressed;
101 | } else {
102 | thumbClasses += config.translateChecked;
103 | }
104 | } else {
105 | thumbClasses += config.translateUnchecked;
106 | }
107 |
108 | return (
109 |
135 | );
136 | }
--------------------------------------------------------------------------------
/components/OptimizedImage.js:
--------------------------------------------------------------------------------
1 | 'use client';
2 |
3 | import { useEffect, useState, useRef } from 'react';
4 |
5 | export default function OptimizedImage({
6 | baseName,
7 | alt,
8 | className = '',
9 | style = {},
10 | onLoad,
11 | onError,
12 | draggable = false,
13 | ...props
14 | }) {
15 | const [loadedFormat, setLoadedFormat] = useState(null);
16 | const [browserSupport, setBrowserSupport] = useState({
17 | avif: false,
18 | webp: false
19 | });
20 | const imgRef = useRef(null);
21 |
22 | // Check browser support for modern image formats
23 | useEffect(() => {
24 | const checkSupport = async () => {
25 | const supportsWebP = () => {
26 | const canvas = document.createElement('canvas');
27 | canvas.width = 1;
28 | canvas.height = 1;
29 | return canvas.toDataURL('image/webp').indexOf('data:image/webp') === 0;
30 | };
31 |
32 | const supportsAVIF = () => {
33 | const canvas = document.createElement('canvas');
34 | canvas.width = 1;
35 | canvas.height = 1;
36 | return canvas.toDataURL('image/avif').indexOf('data:image/avif') === 0;
37 | };
38 |
39 | const support = {
40 | avif: supportsAVIF(),
41 | webp: supportsWebP()
42 | };
43 |
44 | setBrowserSupport(support);
45 |
46 | console.log('🌐 Browser Format Support:', {
47 | AVIF: support.avif,
48 | WebP: support.webp,
49 | userAgent: navigator.userAgent.split(' ').pop()
50 | });
51 | };
52 |
53 | checkSupport();
54 | }, []);
55 |
56 | const handleImageLoad = (event) => {
57 | const src = event.target.currentSrc || event.target.src;
58 | let format = 'PNG';
59 |
60 | if (src.includes('.avif')) format = 'AVIF';
61 | else if (src.includes('.webp')) format = 'WebP';
62 | else if (src.includes('.jpg') || src.includes('.jpeg')) format = 'JPEG';
63 |
64 | setLoadedFormat(format);
65 |
66 | console.log(`✅ OptimizedImage loaded:`, {
67 | format,
68 | src,
69 | baseName,
70 | browserSupport,
71 | savings: format === 'AVIF' ? '~50% vs PNG' : format === 'WebP' ? '~25% vs PNG' : 'No compression'
72 | });
73 |
74 | if (onLoad) onLoad(event);
75 | };
76 |
77 | const handleImageError = (event) => {
78 | const src = event.target.src;
79 | let format = 'Unknown';
80 |
81 | if (src.includes('.avif')) format = 'AVIF';
82 | else if (src.includes('.webp')) format = 'WebP';
83 | else if (src.includes('.png')) format = 'PNG';
84 |
85 | console.warn(`❌ OptimizedImage failed to load:`, {
86 | format,
87 | src,
88 | baseName,
89 | fallbackAvailable: true
90 | });
91 |
92 | if (onError) onError(event);
93 | };
94 |
95 | return (
96 |
37 |
94 |
38 |
93 |
39 |
49 |
50 | {title}
40 | {!isLoading && ( 41 | 47 | )} 48 |{message}
51 | 52 | {requireConfirmation && ( 53 |
54 |
57 | setInputValue(e.target.value)}
61 | placeholder={confirmationPlaceholder}
62 | className="w-full px-3 py-2 text-sm border border-gray-300 dark:border-gray-600 rounded-lg focus:outline-none focus:border-red-500 focus:dark:border-red-500 bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100"
63 | disabled={isLoading}
64 | autoFocus
65 | />
66 |
67 | )}
68 |
69 |
70 |
77 |
91 |
92 | 
127 |
128 | {/* Development indicator */}
129 | {process.env.NODE_ENV === 'development' && loadedFormat && (
130 |
134 | {loadedFormat}
135 |
136 | )}
137 |
138 |
152 | );
153 | }
154 |
155 | // Once doctor context is ready, render the application
156 | return children;
157 | }
--------------------------------------------------------------------------------
/components/ShareModal.js:
--------------------------------------------------------------------------------
1 | 'use client';
2 |
3 | import { useState } from 'react';
4 | import { X, Copy, MessageCircle, CheckCircle, ExternalLink } from 'lucide-react';
5 | import { toast } from 'sonner';
6 |
7 | export default function ShareModal({ isOpen, onClose, shareUrl, title = "Share Document", fileName = "document" }) {
8 | const [copied, setCopied] = useState(false);
9 |
10 | if (!isOpen) return null;
11 |
12 | const copyToClipboard = async () => {
13 | try {
14 | await navigator.clipboard.writeText(shareUrl);
15 | setCopied(true);
16 | toast.success('Link Copied', {
17 | description: 'The share link has been copied to your clipboard'
18 | });
19 |
20 | // Reset copied state after 2 seconds
21 | setTimeout(() => setCopied(false), 2000);
22 | } catch (error) {
23 | console.error('Failed to copy:', error);
24 | toast.error('Copy Failed', {
25 | description: 'Failed to copy link to clipboard'
26 | });
27 | }
28 | };
29 |
30 | const shareOnWhatsApp = () => {
31 | const message = `Hi! I'm sharing a ${title.toLowerCase()} with you. You can view it here: ${shareUrl}`;
32 | const whatsappUrl = `https://wa.me/?text=${encodeURIComponent(message)}`;
33 | window.open(whatsappUrl, '_blank');
34 |
35 | toast.success('Opening WhatsApp', {
36 | description: 'WhatsApp is opening with the share message'
37 | });
38 | };
39 |
40 | const openInNewTab = () => {
41 | window.open(shareUrl, '_blank');
42 | toast.success('Opening Document', {
43 | description: 'Document is opening in a new tab'
44 | });
45 | };
46 |
47 | return (
48 |
139 |
151 |
140 |
144 | 145 | Initializing Application 146 |
147 |148 | Setting up your doctor profile... 149 |
150 |
49 |
146 | );
147 | }
--------------------------------------------------------------------------------
/utils/billGenerator.js:
--------------------------------------------------------------------------------
1 | import jsPDF from 'jspdf';
2 | import { formatDate, formatDateTime } from './dateUtils';
3 | import { storage } from './storage';
4 |
5 | export const generateBillPDF = async (bill, patient) => {
6 | const pdf = new jsPDF();
7 | const pageWidth = pdf.internal.pageSize.width;
8 | const pageHeight = pdf.internal.pageSize.height;
9 | const margin = 15;
10 | let yPosition = 20;
11 |
12 | // Get current doctor context
13 | const doctorContext = storage.getDoctorContext();
14 | const doctorName = doctorContext?.name || 'Dr. Prashant Nikam';
15 | const doctorDegree = doctorContext?.degree || 'BAMS (College Name)';
16 | const hospitalName = doctorContext?.hospitalName || 'Chaitanya Hospital';
17 | const hospitalAddress = doctorContext?.hospitalAddress || 'Deola';
18 |
19 | // Get hospital logo for current doctor
20 | let hospitalLogo = null;
21 | try {
22 | if (doctorContext?.doctorId) {
23 | const logoData = await storage.getHospitalLogo(doctorContext.doctorId);
24 | if (logoData && logoData.base64) {
25 | hospitalLogo = logoData.base64;
26 | }
27 | }
28 | } catch (error) {
29 | console.warn('Could not load hospital logo:', error);
30 | }
31 |
32 | // Header Section
33 | // Hospital Logo (left side)
34 | if (hospitalLogo) {
35 | try {
36 | const imageFormat = hospitalLogo.split(';')[0].split('/')[1].toUpperCase();
37 | const validFormats = ['PNG', 'JPEG', 'JPG', 'WEBP', 'AVIF'];
38 | const format = validFormats.includes(imageFormat) ? imageFormat : 'PNG';
39 |
40 | pdf.addImage(hospitalLogo, format, margin, yPosition, 50, 20);
41 | } catch (error) {
42 | console.warn('Could not add hospital logo to PDF:', error);
43 | // Add placeholder text if logo fails to load
44 | pdf.setFillColor(240, 240, 240);
45 | pdf.rect(margin, yPosition, 50, 20, 'F');
46 | pdf.setFontSize(8);
47 | pdf.setFont('helvetica', 'normal');
48 | pdf.setTextColor(120, 120, 120);
49 | pdf.text('HOSPITAL LOGO', margin + 25, yPosition + 12, { align: 'center' });
50 | }
51 | } else {
52 | // Fallback: Show hospital name as placeholder
53 | pdf.setFillColor(240, 240, 240);
54 | pdf.rect(margin, yPosition, 50, 20, 'F');
55 | pdf.setFontSize(8);
56 | pdf.setFont('helvetica', 'normal');
57 | pdf.setTextColor(120, 120, 120);
58 | pdf.text('HOSPITAL LOGO', margin + 25, yPosition + 12, { align: 'center' });
59 | }
60 |
61 | // Doctor Details (right side)
62 | const doctorDetailsX = pageWidth - margin - 80;
63 | pdf.setTextColor(0, 0, 0);
64 |
65 | pdf.setFontSize(16);
66 | pdf.setFont('helvetica', 'bold');
67 | pdf.text(doctorName, doctorDetailsX, yPosition + 5);
68 |
69 | pdf.setFontSize(12);
70 | pdf.setFont('helvetica', 'normal');
71 | pdf.text(doctorDegree, doctorDetailsX, yPosition + 12);
72 |
73 | pdf.setFontSize(10);
74 | pdf.setTextColor(80, 80, 80);
75 | pdf.text(`${hospitalName}, ${hospitalAddress}`, doctorDetailsX, yPosition + 18);
76 |
77 | yPosition += 30;
78 |
79 | // Horizontal Divider
80 | pdf.setDrawColor(0, 0, 0);
81 | pdf.setLineWidth(0.15);
82 | pdf.line(margin, yPosition, pageWidth - margin, yPosition);
83 |
84 | yPosition += 15;
85 |
86 | // Bill Title
87 | pdf.setFontSize(18);
88 | pdf.setFont('helvetica', 'bold');
89 | pdf.setTextColor(0, 0, 0);
90 | pdf.text('MEDICAL BILL', pageWidth / 2, yPosition, { align: 'center' });
91 | yPosition += 15;
92 |
93 | // Bill Information
94 | pdf.setFontSize(12);
95 | pdf.setFont('helvetica', 'bold');
96 | pdf.text('Bill Information', 20, yPosition);
97 |
98 | yPosition += 10;
99 | pdf.setFontSize(11);
100 | pdf.setFont('helvetica', 'normal');
101 | pdf.text(`Bill ID: ${bill.billId}`, 20, yPosition);
102 | pdf.text(`Date: ${formatDate(bill.createdAt)}`, 120, yPosition);
103 |
104 | yPosition += 8;
105 | pdf.text(`Time: ${formatDateTime(bill.createdAt)}`, 20, yPosition);
106 | pdf.text(`Status: ${bill.isPaid ? 'PAID' : 'PENDING'}`, 120, yPosition);
107 |
108 | yPosition += 15;
109 |
110 | // Patient Information
111 | pdf.setFontSize(12);
112 | pdf.setFont('helvetica', 'bold');
113 | pdf.text('Patient Information', 20, yPosition);
114 |
115 | yPosition += 10;
116 | pdf.setFontSize(11);
117 | pdf.setFont('helvetica', 'normal');
118 | pdf.text(`Name: ${patient.name}`, 20, yPosition);
119 | pdf.text(`Patient ID: ${patient.id}`, 120, yPosition);
120 |
121 | yPosition += 8;
122 | pdf.text(`Age: ${patient.age} years`, 20, yPosition);
123 | pdf.text(`Phone: ${patient.phone}`, 120, yPosition);
124 |
125 | yPosition += 20;
126 |
127 | // Bill Details Table
128 | pdf.setFontSize(12);
129 | pdf.setFont('helvetica', 'bold');
130 | pdf.text('Bill Details', 20, yPosition);
131 | yPosition += 10;
132 |
133 | // Table Header
134 | pdf.setFillColor(240, 240, 240);
135 | pdf.rect(20, yPosition, pageWidth - 40, 10, 'F');
136 | pdf.setFontSize(10);
137 | pdf.setFont('helvetica', 'bold');
138 | pdf.text('Description', 25, yPosition + 7);
139 | pdf.text('Amount (₹)', pageWidth - 50, yPosition + 7);
140 | yPosition += 15;
141 |
142 | // Table Content
143 | pdf.setFont('helvetica', 'normal');
144 | pdf.text(bill.description, 25, yPosition);
145 | pdf.text(bill.amount.toString(), pageWidth - 50, yPosition);
146 | yPosition += 10;
147 |
148 | // Total Line
149 | pdf.line(20, yPosition, pageWidth - 20, yPosition);
150 | yPosition += 10;
151 |
152 | // Total Amount
153 | pdf.setFontSize(14);
154 | pdf.setFont('helvetica', 'bold');
155 | pdf.text('Total Amount: ₹' + bill.amount, pageWidth - 80, yPosition);
156 | yPosition += 20;
157 |
158 | // Payment Status
159 | if (bill.isPaid && bill.paidAt) {
160 | pdf.setFontSize(12);
161 | pdf.setFont('helvetica', 'bold');
162 | pdf.setTextColor(0, 150, 0);
163 | pdf.text('PAYMENT RECEIVED', 20, yPosition);
164 | pdf.setFont('helvetica', 'normal');
165 | pdf.setTextColor(0, 0, 0);
166 | yPosition += 8;
167 | pdf.text(`Payment Date: ${formatDateTime(bill.paidAt)}`, 20, yPosition);
168 | yPosition += 15;
169 | } else {
170 | pdf.setFontSize(12);
171 | pdf.setFont('helvetica', 'bold');
172 | pdf.setTextColor(200, 0, 0);
173 | pdf.text('PAYMENT PENDING', 20, yPosition);
174 | pdf.setTextColor(0, 0, 0);
175 | yPosition += 15;
176 | }
177 |
178 | // Footer
179 | const footerY = pageHeight - 30;
180 | pdf.setDrawColor(0, 0, 0);
181 | pdf.setLineWidth(0.15);
182 | pdf.line(margin, footerY - 5, pageWidth - margin, footerY - 5);
183 |
184 | pdf.setFontSize(6);
185 | pdf.setTextColor(100, 100, 100);
186 | pdf.text('This is a computer generated bill and does not require signature.', pageWidth / 2, footerY, { align: 'center' });
187 |
188 | pdf.setFontSize(6);
189 | pdf.text('Thank you for choosing our medical services.', pageWidth / 2, footerY + 4, { align: 'center' });
190 |
191 | // Return blob instead of auto-downloading
192 | return pdf.output('blob');
193 | };
194 |
--------------------------------------------------------------------------------
/components/PillSelector.js:
--------------------------------------------------------------------------------
1 | 'use client';
2 |
3 | import { useState, useRef, useEffect } from 'react';
4 | import { Search, ChevronLeft, ChevronRight, Plus } from 'lucide-react';
5 | import useScrollToTop from '../hooks/useScrollToTop';
6 |
7 | export default function PillSelector({
8 | title,
9 | items,
10 | onSelect,
11 | searchPlaceholder = "Search...",
12 | addButtonText = "Add Custom",
13 | onAddCustom
14 | }) {
15 | const [searchTerm, setSearchTerm] = useState('');
16 | const [showSearch, setShowSearch] = useState(false);
17 | const scrollContainerRef = useRef(null);
18 | const [canScrollLeft, setCanScrollLeft] = useState(false);
19 | const [canScrollRight, setCanScrollRight] = useState(false);
20 |
21 | // Add scroll to top when component mounts
22 | useScrollToTop();
23 |
24 | const filteredItems = items.filter(item =>
25 | item.toLowerCase().includes(searchTerm.toLowerCase())
26 | );
27 |
28 | const checkScrollability = () => {
29 | if (scrollContainerRef.current) {
30 | const { scrollLeft, scrollWidth, clientWidth } = scrollContainerRef.current;
31 | setCanScrollLeft(scrollLeft > 0);
32 | setCanScrollRight(scrollLeft < scrollWidth - clientWidth - 1);
33 | }
34 | };
35 |
36 | useEffect(() => {
37 | checkScrollability();
38 | const container = scrollContainerRef.current;
39 | if (container) {
40 | container.addEventListener('scroll', checkScrollability);
41 | return () => container.removeEventListener('scroll', checkScrollability);
42 | }
43 | }, [items]);
44 |
45 | const scroll = (direction) => {
46 | if (scrollContainerRef.current) {
47 | const scrollAmount = 200;
48 | scrollContainerRef.current.scrollBy({
49 | left: direction === 'left' ? -scrollAmount : scrollAmount,
50 | behavior: 'smooth'
51 | });
52 | }
53 | };
54 |
55 | const handleSelect = (item) => {
56 | onSelect(item);
57 | setSearchTerm('');
58 | setShowSearch(false);
59 | };
60 |
61 | const handleAddCustom = () => {
62 | if (searchTerm.trim() && onAddCustom) {
63 | onAddCustom(searchTerm.trim());
64 | setSearchTerm('');
65 | setShowSearch(false);
66 | }
67 | };
68 |
69 | return (
70 |
50 | {/* Header */}
51 |
145 |
52 |
54 |
55 | {/* Content */}
56 | {title}
53 |
57 | {/* Share URL Display */}
58 |
134 |
135 | {/* Footer */}
136 |
59 |
80 |
81 | {/* Share Options */}
82 | Share Link:
60 |
61 |
67 |
78 |
79 |
83 |
133 | Share Options:
84 | 85 | {/* Copy Link Button */} 86 | 104 | 105 | {/* WhatsApp Share Button */} 106 | 118 | 119 | {/* Open in New Tab Button */} 120 | 132 |
137 |
143 |
144 |
71 |
166 | );
167 | }
--------------------------------------------------------------------------------
/components/CustomDropdown.js:
--------------------------------------------------------------------------------
1 | 'use client';
2 |
3 | import { useState, useRef, useEffect, forwardRef, useImperativeHandle } from 'react';
4 | import { ChevronDown } from 'lucide-react';
5 |
6 | const CustomDropdown = forwardRef(function CustomDropdown({
7 | options,
8 | value,
9 | onChange,
10 | placeholder,
11 | disabled = false,
12 | onEnterPress,
13 | showDirectionToggle = false,
14 | sortDirection = 'desc',
15 | onDirectionToggle
16 | }, ref) {
17 | const [isOpen, setIsOpen] = useState(false);
18 | const [highlightedIndex, setHighlightedIndex] = useState(-1);
19 | const wrapperRef = useRef(null);
20 | const buttonRef = useRef(null);
21 |
22 | const selectedOption = options.find(option => option.value === value);
23 | const selectedIndex = options.findIndex(option => option.value === value);
24 |
25 | // Expose methods to parent component
26 | useImperativeHandle(ref, () => ({
27 | focus: () => {
28 | buttonRef.current?.focus();
29 | },
30 | open: () => {
31 | setIsOpen(true);
32 | buttonRef.current?.focus();
33 | },
34 | close: () => {
35 | setIsOpen(false);
36 | setHighlightedIndex(-1);
37 | }
38 | }));
39 |
40 | useEffect(() => {
41 | function handleClickOutside(event) {
42 | if (wrapperRef.current && !wrapperRef.current.contains(event.target)) {
43 | setIsOpen(false);
44 | setHighlightedIndex(-1);
45 | }
46 | }
47 | document.addEventListener("mousedown", handleClickOutside);
48 | return () => {
49 | document.removeEventListener("mousedown", handleClickOutside);
50 | };
51 | }, [wrapperRef]);
52 |
53 | useEffect(() => {
54 | if (isOpen && selectedIndex >= 0) {
55 | setHighlightedIndex(selectedIndex);
56 | }
57 | }, [isOpen, selectedIndex]);
58 |
59 | const handleSelect = (optionValue) => {
60 | onChange(optionValue);
61 | setIsOpen(false);
62 | setHighlightedIndex(-1);
63 | if (onEnterPress) {
64 | onEnterPress();
65 | }
66 | };
67 |
68 | const handleSortDirectionClick = (e) => {
69 | e.preventDefault();
70 | e.stopPropagation();
71 | if (onDirectionToggle) {
72 | onDirectionToggle();
73 | }
74 | };
75 |
76 | const handleMainButtonClick = (e) => {
77 | // Check if the click was on the direction toggle area
78 | if (showDirectionToggle && e.target.closest('.direction-toggle')) {
79 | return; // Don't toggle dropdown if clicking on direction toggle
80 | }
81 | if (!disabled) {
82 | setIsOpen(!isOpen);
83 | }
84 | };
85 |
86 | const handleKeyDown = (e) => {
87 | if (disabled) return;
88 |
89 | switch (e.key) {
90 | case 'Enter':
91 | e.preventDefault();
92 | if (isOpen && highlightedIndex >= 0) {
93 | handleSelect(options[highlightedIndex].value);
94 | } else if (isOpen && selectedOption) {
95 | handleSelect(selectedOption.value);
96 | } else if (!isOpen) {
97 | setIsOpen(true);
98 | } else if (onEnterPress) {
99 | setIsOpen(false);
100 | onEnterPress();
101 | }
102 | break;
103 | case 'ArrowDown':
104 | e.preventDefault();
105 | if (!isOpen) {
106 | setIsOpen(true);
107 | setHighlightedIndex(selectedIndex >= 0 ? selectedIndex : 0);
108 | } else {
109 | setHighlightedIndex(prev =>
110 | prev < options.length - 1 ? prev + 1 : 0
111 | );
112 | }
113 | break;
114 | case 'ArrowUp':
115 | e.preventDefault();
116 | if (!isOpen) {
117 | setIsOpen(true);
118 | setHighlightedIndex(selectedIndex >= 0 ? selectedIndex : options.length - 1);
119 | } else {
120 | setHighlightedIndex(prev =>
121 | prev > 0 ? prev - 1 : options.length - 1
122 | );
123 | }
124 | break;
125 | case 'Escape':
126 | setIsOpen(false);
127 | setHighlightedIndex(-1);
128 | buttonRef.current?.blur();
129 | break;
130 | case ' ':
131 | e.preventDefault();
132 | if (!isOpen) {
133 | setIsOpen(true);
134 | }
135 | break;
136 | }
137 | };
138 |
139 | return (
140 |
72 |
99 |
100 | {showSearch && (
101 | {title}
73 |
74 |
81 | {canScrollLeft && (
82 |
88 | )}
89 | {canScrollRight && (
90 |
96 | )}
97 |
98 |
102 |
145 | )}
146 |
147 | {/* Horizontal scrolling pills */}
148 |
103 |
113 |
114 | {searchTerm && (
115 |
116 | {filteredItems.length > 0 ? (
117 |
143 | )}
144 |
118 | {filteredItems.slice(0, 10).map((item, index) => (
119 |
126 | ))}
127 |
128 | ) : (
129 |
130 |
141 | )}
142 | No matches found
131 | {onAddCustom && ( 132 | 139 | )} 140 |
149 |
165 |
154 | {items.map((item, index) => (
155 |
162 | ))}
163 |
164 |
141 |
193 | );
194 | });
195 |
196 | export default CustomDropdown;
197 |
--------------------------------------------------------------------------------
/components/KeyGeneratorModal.js:
--------------------------------------------------------------------------------
1 | 'use client';
2 |
3 | import { useState, useRef, useEffect } from 'react';
4 | import { Copy, Check } from 'lucide-react';
5 | import { toast } from 'sonner';
6 |
7 | export default function KeyGeneratorTooltip({ isOpen, onClose, triggerRef }) {
8 | const [password, setPassword] = useState('');
9 | const [generatedKey, setGeneratedKey] = useState('');
10 | const [isLoading, setIsLoading] = useState(false);
11 | const [copied, setCopied] = useState(false);
12 | const [state, setState] = useState('input'); // 'input', 'loading', 'result'
13 | const inputRef = useRef(null);
14 | const tooltipRef = useRef(null);
15 | const autoCloseTimerRef = useRef(null);
16 |
17 | useEffect(() => {
18 | if (isOpen && state === 'input') {
19 | setTimeout(() => {
20 | inputRef.current?.focus();
21 | }, 300);
22 | }
23 | }, [isOpen, state]);
24 |
25 | useEffect(() => {
26 | if (isOpen) {
27 | setState('input');
28 | setPassword('');
29 | setGeneratedKey('');
30 | setCopied(false);
31 | setIsLoading(false);
32 | // Clear any existing auto-close timer when opening
33 | if (autoCloseTimerRef.current) {
34 | clearTimeout(autoCloseTimerRef.current);
35 | autoCloseTimerRef.current = null;
36 | }
37 | }
38 | }, [isOpen]);
39 |
40 | const handleKeyPress = async (e) => {
41 | if (e.key === 'Enter' && password.trim() && !isLoading) {
42 | await handleGenerate();
43 | }
44 | };
45 |
46 | const handleGenerate = async () => {
47 | if (!password.trim()) return;
48 |
49 | setState('loading');
50 | setIsLoading(true);
51 |
52 | try {
53 | // Create a minimum loading time promise
54 | const minLoadingTime = new Promise(resolve => setTimeout(resolve, 200));
55 |
56 | const apiCall = fetch('/api/auth/generate-key', {
57 | method: 'POST',
58 | headers: {
59 | 'Content-Type': 'application/json',
60 | },
61 | body: JSON.stringify({ password }),
62 | });
63 |
64 | // Wait for both the API call and minimum loading time
65 | const [response] = await Promise.all([apiCall, minLoadingTime]);
66 | const data = await response.json();
67 |
68 | if (data.success) {
69 | setGeneratedKey(data.key);
70 | setState('result');
71 |
72 | // Automatically copy the key to clipboard
73 | try {
74 | await navigator.clipboard.writeText(data.key);
75 | toast.success('Key generated and copied to clipboard');
76 |
77 | // Set auto-close timer for 2 seconds after successful copy
78 | autoCloseTimerRef.current = setTimeout(() => {
79 | handleClose();
80 | }, 2000);
81 | } catch (copyError) {
82 | toast.success('Registration key generated successfully');
83 | console.warn('Auto-copy failed:', copyError);
84 | }
85 | } else {
86 | toast.error(data.error || 'Failed to generate key');
87 | setState('input');
88 | setPassword('');
89 | }
90 | } catch (error) {
91 | console.error('Key generation error:', error);
92 | toast.error('Network error. Please try again.');
93 | setState('input');
94 | setPassword('');
95 | } finally {
96 | setIsLoading(false);
97 | }
98 | };
99 |
100 | const handleCopy = async () => {
101 | try {
102 | await navigator.clipboard.writeText(generatedKey);
103 | setCopied(true);
104 | toast.success('Key copied to clipboard');
105 | setTimeout(() => setCopied(false), 2000);
106 | } catch (error) {
107 | toast.error('Failed to copy key');
108 | }
109 | };
110 |
111 | const handleClose = () => {
112 | // Clear auto-close timer when manually closing
113 | if (autoCloseTimerRef.current) {
114 | clearTimeout(autoCloseTimerRef.current);
115 | autoCloseTimerRef.current = null;
116 | }
117 | setState('input');
118 | setPassword('');
119 | setGeneratedKey('');
120 | setCopied(false);
121 | onClose();
122 | };
123 |
124 | // Click outside handler
125 | useEffect(() => {
126 | const handleClickOutside = (event) => {
127 | if (isOpen && tooltipRef.current && !tooltipRef.current.contains(event.target) &&
128 | triggerRef.current && !triggerRef.current.contains(event.target)) {
129 | handleClose();
130 | }
131 | };
132 |
133 | if (isOpen) {
134 | document.addEventListener('mousedown', handleClickOutside);
135 | return () => document.removeEventListener('mousedown', handleClickOutside);
136 | }
137 | }, [isOpen]);
138 |
139 | // Cleanup auto-close timer on unmount
140 | useEffect(() => {
141 | return () => {
142 | if (autoCloseTimerRef.current) {
143 | clearTimeout(autoCloseTimerRef.current);
144 | }
145 | };
146 | }, []);
147 |
148 | return (
149 |
145 |
169 |
170 |
171 |
176 | {options.map((option, index) => (
177 |
192 | handleSelect(option.value)}
180 | onMouseEnter={() => setHighlightedIndex(index)}
181 | className={`cursor-pointer mb-1 rounded-lg select-none relative py-2.5 px-3 font-medium transition-colors ${index === highlightedIndex
182 | ? 'bg-blue-50 dark:bg-gray-800 text-blue-600 dark:text-blue-300'
183 | : option.value === value ? 'bg-[#EFF6FF] dark:bg-gray-800 text-[#1D4ED8] dark:text-blue-300' : 'text-[#374151] dark:text-gray-600 hover:bg-[#F3F4F6]'
184 | }`}
185 | >
186 |
187 | {option.label}
188 |
189 |
190 | ))}
191 |
162 | {state === 'input' && (
163 |
210 | );
211 | }
212 |
--------------------------------------------------------------------------------
/app/api/auth/register/route.js:
--------------------------------------------------------------------------------
1 | import { NextResponse } from 'next/server';
2 | import bcrypt from 'bcryptjs';
3 | import clientPromise from '../../../../lib/mongodb';
4 | import { Redis } from '@upstash/redis';
5 |
6 | const redis = new Redis({
7 | url: process.env.UPSTASH_REDIS_REST_URL,
8 | token: process.env.UPSTASH_REDIS_REST_TOKEN,
9 | });
10 |
11 | const REGISTER_ATTEMPT_LIMIT = 5;
12 | const REGISTER_ATTEMPT_WINDOW = 30 * 60; // 30 minutes
13 | const REGISTER_LOCKOUT_TIME = 60 * 60; // 1 hour
14 |
15 | async function checkRegisterRateLimit(email, phone, ip) {
16 | const key = `register:attempts:${email}:${phone}:${ip}`;
17 | const lockKey = `register:lockout:${email}:${phone}:${ip}`;
18 | const locked = await redis.get(lockKey);
19 | if (locked) return { locked: true };
20 |
21 | let attempts = await redis.get(key);
22 | attempts = attempts ? parseInt(attempts) : 0;
23 | if (attempts >= REGISTER_ATTEMPT_LIMIT) {
24 | await redis.set(lockKey, '1', { ex: REGISTER_LOCKOUT_TIME });
25 | return { locked: true };
26 | }
27 | return { locked: false, attempts, key, lockKey };
28 | }
29 |
30 | async function incrementRegisterAttempts(key) {
31 | await redis.incr(key);
32 | await redis.expire(key, REGISTER_ATTEMPT_WINDOW);
33 | }
34 |
35 | async function resetRegisterAttempts(key, lockKey) {
36 | await redis.del(key);
37 | await redis.del(lockKey);
38 | }
39 |
40 | // Generate unique doctor ID
41 | function generateDoctorId(firstName, lastName, hospitalName) {
42 | const baseId = `${firstName.toLowerCase().replace(/[^a-z]/g, '')}_${lastName.toLowerCase().replace(/[^a-z]/g, '')}_${hospitalName.toLowerCase().replace(/[^a-z]/g, '')}`;
43 | return baseId;
44 | }
45 |
46 | export async function POST(request) {
47 | // Redirect HTTP to HTTPS (only in production)
48 | if (process.env.NODE_ENV === 'production' && request.headers.get('x-forwarded-proto') === 'http') {
49 | return NextResponse.redirect(`https://${request.headers.get('host')}${request.url}`, 308);
50 | }
51 |
52 | try {
53 | const {
54 | firstName,
55 | lastName,
56 | email,
57 | password,
58 | hospitalName,
59 | hospitalAddress,
60 | degree,
61 | registrationNumber,
62 | phone,
63 | accessKey
64 | } = await request.json();
65 |
66 | // Validate required fields
67 | if (!firstName || !lastName || !email || !password || !hospitalName || !degree || !registrationNumber || !phone) {
68 | return NextResponse.json(
69 | { success: false, error: 'All required fields must be provided including first name, last name, and phone number' },
70 | { status: 400 }
71 | );
72 | }
73 |
74 | // Validate email format
75 | const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
76 | if (!emailRegex.test(email)) {
77 | return NextResponse.json(
78 | { success: false, error: 'Invalid email format' },
79 | { status: 400 }
80 | );
81 | }
82 |
83 | // Validate phone format (basic validation)
84 | const phoneRegex = /^[\+]?[1-9][\d]{3,14}$/;
85 | if (!phoneRegex.test(phone.replace(/[\s\-\(\)]/g, ''))) {
86 | return NextResponse.json(
87 | { success: false, error: 'Invalid phone number format' },
88 | { status: 400 }
89 | );
90 | }
91 |
92 | // Validate password strength
93 | const strongPasswordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*()_\-+=\[\]{};':",.<>/?\\|`~]).{8,}$/;
94 | if (!strongPasswordRegex.test(password)) {
95 | return NextResponse.json(
96 | { success: false, error: 'Password must be at least 8 characters long and include uppercase, lowercase, number, and special character.' },
97 | { status: 400 }
98 | );
99 | }
100 |
101 | const { doctorService } = await import('../../../../services/doctorService');
102 |
103 | const client = await clientPromise;
104 | const db = client.db('doc-prescrip');
105 | const doctors = db.collection('doctors');
106 |
107 | // Check if email already exists
108 | const emailExists = await doctors.findOne({ email });
109 | if (emailExists) {
110 | return NextResponse.json(
111 | { success: false, error: 'An account with this email already exists' },
112 | { status: 409 }
113 | );
114 | }
115 |
116 | // Check if phone already exists
117 | const phoneExists = await doctors.findOne({ phone });
118 | if (phoneExists) {
119 | return NextResponse.json(
120 | { success: false, error: 'An account with this phone number already exists' },
121 | { status: 409 }
122 | );
123 | }
124 |
125 | let accessType = 'trial';
126 | let expiryDate = new Date();
127 | expiryDate.setMonth(expiryDate.getMonth() + 6); // 6 months from now
128 |
129 | // Validate access key if provided
130 | if (accessKey && accessKey.trim()) {
131 | const keyValid = await doctorService.validateRegistrationKey(accessKey.trim());
132 | if (!keyValid) {
133 | return NextResponse.json(
134 | { success: false, error: 'Invalid or already used access key' },
135 | { status: 400 }
136 | );
137 | }
138 | accessType = 'lifetime_free';
139 | expiryDate = null;
140 | }
141 |
142 | // Generate unique doctor ID
143 | let doctorId = generateDoctorId(firstName, lastName, hospitalName);
144 |
145 | // Ensure uniqueness
146 | let counter = 1;
147 | let uniqueDoctorId = doctorId;
148 | while (await doctors.findOne({ doctorId: uniqueDoctorId })) {
149 | uniqueDoctorId = `${doctorId}_${counter}`;
150 | counter++;
151 | }
152 |
153 | // Hash password
154 | const salt = await bcrypt.genSalt(10);
155 | const passwordHash = await bcrypt.hash(password, salt);
156 |
157 | // Create doctor object
158 | const newDoctor = {
159 | doctorId: uniqueDoctorId,
160 | firstName,
161 | lastName,
162 | name: `${firstName} ${lastName}`,
163 | email,
164 | passwordHash,
165 | hospitalName,
166 | hospitalAddress: hospitalAddress || '',
167 | degree,
168 | registrationNumber,
169 | phone,
170 | accessType,
171 | expiryDate,
172 | emailVerified: false, // Will be verified through NextAuth
173 | isActive: true,
174 | profileComplete: true,
175 | createdAt: new Date(),
176 | updatedAt: new Date()
177 | };
178 |
179 | const ip = request.headers.get('x-forwarded-for') || 'unknown';
180 |
181 | // Rate limiting and lockout
182 | const rate = await checkRegisterRateLimit(email, phone, ip);
183 | if (rate.locked) {
184 | return NextResponse.json(
185 | { success: false, error: 'Too many registration attempts. Please try again later.' },
186 | { status: 429 }
187 | );
188 | }
189 |
190 | // Save doctor
191 | const result = await doctors.insertOne(newDoctor);
192 |
193 | if (result.insertedId) {
194 | await resetRegisterAttempts(rate.key, rate.lockKey);
195 | // If access key was used, mark it as used
196 | if (accessKey && accessKey.trim()) {
197 | await doctorService.useRegistrationKey(accessKey.trim(), doctorId);
198 | }
199 |
200 | return NextResponse.json({
201 | success: true,
202 | message: 'Doctor registered successfully. Please sign in with your credentials.',
203 | doctor: {
204 | doctorId: newDoctor.doctorId,
205 | firstName: newDoctor.firstName,
206 | lastName: newDoctor.lastName,
207 | name: newDoctor.name,
208 | email: newDoctor.email,
209 | hospitalName: newDoctor.hospitalName,
210 | hospitalAddress: newDoctor.hospitalAddress,
211 | degree: newDoctor.degree,
212 | registrationNumber: newDoctor.registrationNumber,
213 | phone: newDoctor.phone,
214 | accessType: newDoctor.accessType,
215 | expiryDate: newDoctor.expiryDate
216 | }
217 | });
218 | } else {
219 | await incrementRegisterAttempts(rate.key);
220 | return NextResponse.json(
221 | { success: false, error: 'Failed to register doctor' },
222 | { status: 500 }
223 | );
224 | }
225 | } catch (error) {
226 | console.error('Doctor registration error:', error);
227 | return NextResponse.json(
228 | { success: false, error: 'Internal server error' },
229 | { status: 500 }
230 | );
231 | }
232 | }
233 |
--------------------------------------------------------------------------------
/components/SharePDFButton.js:
--------------------------------------------------------------------------------
1 | 'use client'
2 | import { useState } from 'react'
3 | import { useSession, signIn } from 'next-auth/react'
4 | import { Share2, Loader2 } from 'lucide-react'
5 | import { storage } from '../utils/storage'
6 | import { toast } from 'sonner'
7 |
8 | export default function SharePDFButton({
9 | pdfUrl,
10 | filename,
11 | phone,
12 | disabled,
13 | type,
14 | patientName,
15 | visitDate,
16 | billDate,
17 | amount,
18 | isPaid,
19 | certificateDate,
20 | certificateFor,
21 | className,
22 | variant = 'button', // 'button' or 'dropdown'
23 | onShare,
24 | customText, // Add customText prop
25 | // Add these props for regeneration
26 | prescription,
27 | patient,
28 | bill
29 | }) {
30 | const { data: session, status } = useSession()
31 | const [isUploading, setIsUploading] = useState(false)
32 |
33 | const generateMessage = () => {
34 | // Get current doctor context
35 | const currentDoctor = storage.getDoctorContext();
36 | const doctorName = currentDoctor?.name || 'Dr. Prashant Nikam';
37 |
38 | if (type === 'prescription') {
39 | return `Hello ${patientName},
40 |
41 | Your prescription for the consultation on ${visitDate} is ready.
42 |
43 | Please find your prescription attached.
44 |
45 | Thank you for visiting us.
46 |
47 | Best regards,
48 | ${doctorName}`
49 | } else if (type === 'bill') {
50 | return `Hello ${patientName},
51 |
52 | Your bill for the consultation on ${billDate} is ready.
53 |
54 | Amount: ₹${amount}
55 | Status: ${isPaid ? 'Paid' : 'Pending'}
56 |
57 | Please find your bill attached.
58 |
59 | Thank you for visiting us.
60 |
61 | Best regards,
62 | ${doctorName}`
63 | } else if (type === 'certificate') {
64 | return `Hello ${patientName},
65 |
66 | Your medical certificate dated ${certificateDate} is ready.
67 |
68 | Certificate Purpose: ${certificateFor}
69 |
70 | Please find your certificate attached.
71 |
72 | Thank you for visiting us.
73 |
74 | Best regards,
75 | ${doctorName}`
76 | }
77 | return `Hello ${patientName}, your document is ready.`
78 | }
79 |
80 | const handleClick = async () => {
81 | if (status === 'loading') {
82 | toast.info('Please Wait', {
83 | description: 'Checking authentication status...'
84 | });
85 | return
86 | }
87 |
88 | if (!session) {
89 | try {
90 | await signIn('google', {
91 | callbackUrl: window.location.href,
92 | redirect: false
93 | })
94 | } catch (error) {
95 | console.error('Sign in error:', error)
96 | toast.error('Sign In Failed', {
97 | description: 'Failed to sign in. Please try again.'
98 | });
99 | }
100 | return
101 | }
102 |
103 | // Check if session has authentication error
104 | if (session.error === "RefreshAccessTokenError") {
105 | toast.warning('Session Expired', {
106 | description: 'Your session has expired. Please sign in again.'
107 | });
108 | signIn('google', { callbackUrl: window.location.href })
109 | return
110 | }
111 |
112 | setIsUploading(true)
113 |
114 | try {
115 | let validPdfUrl = pdfUrl
116 |
117 | // If no PDF URL or we suspect it might be invalid, try to regenerate
118 | if (!validPdfUrl || validPdfUrl.startsWith('blob:')) {
119 | if (type === 'prescription' && prescription && patient) {
120 | validPdfUrl = await storage.regeneratePDFIfNeeded(prescription, patient, 'prescription')
121 | } else if (type === 'bill' && bill && patient) {
122 | validPdfUrl = await storage.regeneratePDFIfNeeded(bill, patient, 'bill')
123 | }
124 | }
125 |
126 | if (!validPdfUrl) {
127 | toast.error('PDF Not Available', {
128 | description: 'PDF is not available. Please try regenerating the document.'
129 | });
130 | return
131 | }
132 |
133 | // Convert blob URL to blob
134 | const response = await fetch(validPdfUrl)
135 | if (!response.ok) {
136 | throw new Error('Failed to fetch PDF')
137 | }
138 |
139 | const blob = await response.blob()
140 |
141 | // Create FormData to send the file
142 | const formData = new FormData()
143 | formData.append('file', blob, filename)
144 | formData.append('filename', filename)
145 | formData.append('patientName', patientName)
146 | formData.append('visitDate', visitDate || new Date().toISOString().split("T")[0])
147 | formData.append('billDate', billDate || new Date().toISOString().split("T")[0])
148 | formData.append('amount', amount || '0')
149 | formData.append('isPaid', isPaid ? 'true' : 'false')
150 | formData.append('certificateDate', certificateDate || new Date().toISOString().split("T")[0])
151 | formData.append('certificateFor', certificateFor || 'General')
152 |
153 | const res = await fetch('/api/upload-to-drive', {
154 | method: 'POST',
155 | body: formData,
156 | })
157 |
158 | const data = await res.json()
159 |
160 | if (!res.ok) {
161 | if (res.status === 401) {
162 | // Token expired or invalid, trigger re-authentication
163 | toast.warning('Authentication Required', {
164 | description: 'Your Google authentication has expired. Please sign in again.'
165 | });
166 | signIn('google', { callbackUrl: window.location.href })
167 | return
168 | }
169 | throw new Error(data.error || 'Upload failed')
170 | }
171 |
172 | if (data.link) {
173 | const message = generateMessage()
174 | const whatsappMessage = `${message}\n\nDocument link: ${data.link}`
175 | const encoded = encodeURIComponent(whatsappMessage)
176 | const phoneNumber = phone.replace(/\D/g, '') // Remove non-digits
177 | const formattedPhone = phoneNumber.startsWith('91') ? phoneNumber : `91${phoneNumber}`
178 |
179 | window.open(`https://wa.me/${formattedPhone}?text=${encoded}`, '_blank')
180 |
181 | toast.success('Document Shared', {
182 | description: `${type === 'prescription' ? 'Prescription' : type === 'bill' ? 'Bill' : 'Certificate'} shared via WhatsApp successfully`
183 | });
184 |
185 | // Call onShare callback if provided (for dropdown variant)
186 | if (onShare) {
187 | onShare()
188 | }
189 | } else {
190 | throw new Error('No link received from Google Drive')
191 | }
192 | } catch (error) {
193 | console.error('Error sharing PDF:', error)
194 | if (error.message.includes('Unauthorized') || error.message.includes('authentication')) {
195 | toast.warning('Authentication Required', {
196 | description: 'Please sign in with Google to share documents'
197 | });
198 | signIn('google', { callbackUrl: window.location.href })
199 | } else {
200 | toast.error('Share Failed', {
201 | description: `Failed to share PDF: ${error.message}`
202 | });
203 | }
204 | } finally {
205 | setIsUploading(false)
206 | }
207 | }
208 |
209 | // Dropdown variant styling
210 | if (variant === 'dropdown') {
211 | return (
212 |
220 | )
221 | }
222 |
223 | // Default button variant styling
224 | return (
225 |
239 | )
240 | }
241 |
--------------------------------------------------------------------------------
/components/CustomSelect.js:
--------------------------------------------------------------------------------
1 | 'use client';
2 |
3 | import { useState, useRef, useEffect } from 'react';
4 | import { ChevronDown, Check } from 'lucide-react';
5 |
6 | export default function CustomSelect({ options, value, onChange, placeholder, onAddNew }) {
7 | const [isOpen, setIsOpen] = useState(false);
8 | const [searchTerm, setSearchTerm] = useState('');
9 | const [highlightedIndex, setHighlightedIndex] = useState(-1);
10 | const wrapperRef = useRef(null);
11 | const inputRef = useRef(null);
12 | const optionsListRef = useRef(null);
13 |
14 | const selectedOption = options.find(option => option.value === value);
15 |
16 | useEffect(() => {
17 | function handleClickOutside(event) {
18 | if (wrapperRef.current && !wrapperRef.current.contains(event.target)) {
19 | setIsOpen(false);
20 | setSearchTerm('');
21 | setHighlightedIndex(-1);
22 | }
23 | }
24 | document.addEventListener("mousedown", handleClickOutside);
25 | return () => {
26 | document.removeEventListener("mousedown", handleClickOutside);
27 | };
28 | }, [wrapperRef]);
29 |
30 | useEffect(() => {
31 | if (isOpen && inputRef.current) {
32 | inputRef.current.focus();
33 | }
34 | }, [isOpen]);
35 |
36 | // Reset highlighted index when search term changes
37 | useEffect(() => {
38 | setHighlightedIndex(-1);
39 | }, [searchTerm]);
40 |
41 | // Scroll highlighted option into view
42 | useEffect(() => {
43 | if (highlightedIndex >= 0 && optionsListRef.current) {
44 | const highlightedElement = optionsListRef.current.children[highlightedIndex];
45 | if (highlightedElement) {
46 | highlightedElement.scrollIntoView({
47 | behavior: 'smooth',
48 | block: 'nearest'
49 | });
50 | }
51 | }
52 | }, [highlightedIndex]);
53 |
54 | const filteredOptions = options.filter(option =>
55 | option.label.toLowerCase().includes(searchTerm.toLowerCase())
56 | );
57 |
58 | const handleSelect = (optionValue) => {
59 | onChange(optionValue);
60 | setIsOpen(false);
61 | setSearchTerm('');
62 | setHighlightedIndex(-1);
63 | };
64 |
65 | const handleKeyDown = (e) => {
66 | if (!isOpen) {
67 | if (e.key === 'Enter' || e.key === ' ') {
68 | e.preventDefault();
69 | setIsOpen(true);
70 | }
71 | return;
72 | }
73 |
74 | switch (e.key) {
75 | case 'Enter':
76 | e.preventDefault();
77 | if (searchTerm.length >= 1) {
78 | // If user is searching and has typed at least one letter
79 | if (highlightedIndex >= 0 && filteredOptions[highlightedIndex]) {
80 | // Select highlighted option
81 | handleSelect(filteredOptions[highlightedIndex].value);
82 | } else if (filteredOptions.length > 0) {
83 | // Select first (most relevant) option
84 | handleSelect(filteredOptions[0].value);
85 | } else if (onAddNew && searchTerm.trim()) {
86 | // No matches found, create new with search term
87 | onAddNew(searchTerm.trim());
88 | setIsOpen(false);
89 | setSearchTerm('');
90 | setHighlightedIndex(-1);
91 | }
92 | } else if (highlightedIndex >= 0 && filteredOptions[highlightedIndex]) {
93 | // No search term, select highlighted option
94 | handleSelect(filteredOptions[highlightedIndex].value);
95 | }
96 | break;
97 |
98 | case 'ArrowDown':
99 | e.preventDefault();
100 | setHighlightedIndex(prev => {
101 | const maxIndex = filteredOptions.length - 1;
102 | return prev < maxIndex ? prev + 1 : 0;
103 | });
104 | break;
105 |
106 | case 'ArrowUp':
107 | e.preventDefault();
108 | setHighlightedIndex(prev => {
109 | const maxIndex = filteredOptions.length - 1;
110 | return prev > 0 ? prev - 1 : maxIndex;
111 | });
112 | break;
113 |
114 | case 'Escape':
115 | e.preventDefault();
116 | setIsOpen(false);
117 | setSearchTerm('');
118 | setHighlightedIndex(-1);
119 | break;
120 |
121 | case 'Tab':
122 | // Allow tab to close dropdown and move to next element
123 | setIsOpen(false);
124 | setSearchTerm('');
125 | setHighlightedIndex(-1);
126 | break;
127 |
128 | default:
129 | // For any other key, reset highlighted index to allow natural search
130 | if (e.key.length === 1) {
131 | setHighlightedIndex(-1);
132 | }
133 | break;
134 | }
135 | };
136 |
137 | const handleMouseEnter = (index) => {
138 | setHighlightedIndex(index);
139 | };
140 |
141 | const handleMouseLeave = () => {
142 | setHighlightedIndex(-1);
143 | };
144 |
145 | return (
146 |
166 | setPassword(e.target.value)}
171 | onKeyPress={handleKeyPress}
172 | className="w-full px-3 py-2 text-xs border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-700 text-gray-900 dark:text-white placeholder-gray-500 dark:placeholder-gray-400 focus:outline-none focus:ring-2 focus:ring-blue-500 dark:focus:ring-blue-400 focus:border-transparent transition-all duration-300"
173 | placeholder="Admin Password"
174 | />
175 |
176 | )}
177 |
178 | {state === 'loading' && (
179 |
182 |
183 |
184 | )}
185 |
186 | {state === 'result' && (
187 |
190 |
208 | )}
209 |
191 |
206 |
207 |
192 | {generatedKey}
193 |
194 |
205 |
147 |
158 |
159 |
238 | );
239 | }
240 |
--------------------------------------------------------------------------------
164 |
237 |
165 | setSearchTerm(e.target.value)}
171 | onKeyDown={handleKeyDown}
172 | className="w-full px-3 py-2 border border-gray-300 dark:border-gray-700 rounded-md text-sm focus:outline-none focus:ring-0 focus:ring-blue-500 focus:border-blue-500 dark:focus:border-blue-500"
173 | />
174 |
175 |
176 |
177 | {filteredOptions.length > 0 ? (
178 | filteredOptions.map((option, index) => (
179 |
222 |
223 | {onAddNew && filteredOptions.length > 0 && (
224 | handleSelect(option.value)}
182 | onMouseEnter={() => handleMouseEnter(index)}
183 | onMouseLeave={handleMouseLeave}
184 | className={`cursor-pointer select-none relative py-2 pl-3 pr-9 text-gray-900 dark:text-white flex items-center transition-colors ${
185 | highlightedIndex === index
186 | ? 'bg-blue-50 dark:bg-blue-900/20 text-blue-600 dark:text-blue-400'
187 | : option.value === value
188 | ? 'bg-gray-50 dark:bg-gray-800 hover:bg-gray-100 dark:hover:bg-gray-700'
189 | : 'hover:bg-gray-50 dark:hover:bg-gray-800'
190 | }`}
191 | >
192 |
193 | {option.label}
194 |
195 | {option.value === value && (
196 |
197 |
198 |
199 | )}
200 |
201 | ))
202 | ) : (
203 | onAddNew ? (
204 | {
206 | onAddNew(searchTerm.trim());
207 | setIsOpen(false);
208 | setSearchTerm('');
209 | setHighlightedIndex(-1);
210 | }}
211 | className="cursor-pointer select-none relative py-2 px-3 hover:bg-gray-50 dark:hover:bg-gray-800 text-blue-600 text-sm"
212 | >
213 | Add "{searchTerm}" as new patient
214 |
215 | ) : (
216 |
217 | No options found.
218 |
219 | )
220 | )}
221 | {
226 | onChange('new');
227 | setIsOpen(false);
228 | setSearchTerm('');
229 | setHighlightedIndex(-1);
230 | }}
231 | className="cursor-pointer select-none relative py-2 px-3 hover:bg-gray-50 dark:hover:bg-gray-800 text-blue-600 border-t border-gray-200 dark:border-gray-600 mt-1 pt-2 text-sm"
232 | >
233 | Add New Patient...
234 |
235 | )}
236 |