819 lines
25 KiB
TypeScript
819 lines
25 KiB
TypeScript
import { onRequest } from "firebase-functions/v2/https";
|
|
import { Request } from "firebase-functions/v2/https";
|
|
import * as admin from 'firebase-admin';
|
|
import * as express from "express";
|
|
import * as logger from "firebase-functions/logger";
|
|
import * as os from 'os';
|
|
import * as path from 'path';
|
|
import * as fs from 'fs';
|
|
import * as https from 'https';
|
|
import axios from "axios";
|
|
|
|
const formData = require('form-data');
|
|
const Mailgun = require('mailgun.js');
|
|
const { convert } = require('html-to-text');
|
|
const twilio = require('twilio');
|
|
|
|
|
|
if (!admin.apps.length) {
|
|
admin.initializeApp();
|
|
}
|
|
export const sendEmailWithAttachment = onRequest({
|
|
region: process.env.SERVICES_RGN
|
|
}, async (request: Request, response: express.Response) => {
|
|
try {
|
|
const { toAddress, subject, message, fileUrl, fileName } = request.body;
|
|
|
|
if (!toAddress || !subject || !message || !fileUrl) {
|
|
response.status(400).json({
|
|
error: 'Missing required fields (toAddress, subject, message, fileUrl)'
|
|
});
|
|
return;
|
|
}
|
|
const tempFilePath = path.join(os.tmpdir(), fileName || 'attachment.pdf');
|
|
await new Promise<void>((resolve, reject) => {
|
|
const file = fs.createWriteStream(tempFilePath);
|
|
https.get(fileUrl, (res) => {
|
|
res.pipe(file);
|
|
file.on('finish', () => {
|
|
file.close();
|
|
resolve();
|
|
});
|
|
}).on('error', (err) => {
|
|
fs.unlink(tempFilePath, () => { });
|
|
reject(err);
|
|
});
|
|
});
|
|
|
|
const mailgun = new Mailgun(formData);
|
|
const client = mailgun.client({ username: 'api', key: process.env.MAILGUN_API_KEY });
|
|
|
|
const options = {
|
|
wordwrap: 130,
|
|
};
|
|
const textMessage = convert(message, options);
|
|
const fileBuffer = fs.readFileSync(tempFilePath);
|
|
const attachmentFilename = fileName || path.basename(fileUrl.split('?')[0]);
|
|
|
|
const data = {
|
|
from: process.env.MAILGUN_FROM_ADDRESS,
|
|
to: toAddress,
|
|
subject: subject,
|
|
text: textMessage,
|
|
html: message,
|
|
attachment: {
|
|
data: fileBuffer,
|
|
filename: attachmentFilename,
|
|
contentType: 'application/pdf',
|
|
}
|
|
};
|
|
|
|
const result = await client.messages.create(process.env.MAILGUN_SERVER, data);
|
|
fs.unlinkSync(tempFilePath);
|
|
|
|
logger.info('Email with attachment from URL sent successfully');
|
|
response.json({ success: true, result });
|
|
} catch (error) {
|
|
logger.error('Error sending email with attachment from URL:', error);
|
|
response.status(500).json({ success: false, error: error instanceof Error ? error.message : String(error) });
|
|
}
|
|
});
|
|
export const sendEmailMessage = onRequest({
|
|
region: process.env.SERVICES_RGN
|
|
}, (request: Request, response: express.Response) => {
|
|
const mailgun = new Mailgun(formData);
|
|
const mailGunClient = mailgun.client({ username: 'api', key: process.env.MAILGUN_API_KEY });
|
|
|
|
const toAddress = request.body.toAddress;
|
|
const subject = request.body.subject;
|
|
const message = request.body.message;
|
|
const options = {
|
|
wordwrap: 130,
|
|
};
|
|
|
|
const textMessage = convert(message, options);
|
|
mailGunClient.messages.create(process.env.MAILGUN_SERVER, {
|
|
from: process.env.MAILGUN_FROM_ADDRESS,
|
|
to: toAddress,
|
|
subject: subject,
|
|
text: textMessage,
|
|
html: message
|
|
}).then((res: any) => {
|
|
logger.info(res);
|
|
response.send(res);
|
|
}).catch((err: any) => {
|
|
logger.error(err);
|
|
response.send(err);
|
|
});
|
|
});
|
|
|
|
export const sendSMSMessage = onRequest({
|
|
region: process.env.SERVICES_RGN
|
|
}, (request: Request, response: express.Response) => {
|
|
const client = twilio(process.env.TWILIO_ACCOUNT_SID, process.env.TWILIO_AUTH_TOKEN);
|
|
const { to, body } = request.body;
|
|
client.messages
|
|
.create({
|
|
body: body,
|
|
from: process.env.TWILIO_PHONE_NUMBER,
|
|
to: to
|
|
})
|
|
.then((message: any) => {
|
|
logger.info('SMS sent successfully:', message.sid);
|
|
response.json({ success: true, messageId: message.sid });
|
|
})
|
|
.catch((error: any) => {
|
|
logger.error('Error sending SMS:', error);
|
|
response.status(500).json({ success: false, error: error.message });
|
|
});
|
|
});
|
|
|
|
export const createCashfreeOrder = onRequest({
|
|
region: process.env.SERVICES_RGN
|
|
}, async (request: Request, response: express.Response) => {
|
|
try {
|
|
const authHeader = request.headers.authorization;
|
|
if (!authHeader || !authHeader.startsWith('Bearer ')) {
|
|
response.status(401).json({ error: 'Unauthorized' });
|
|
return;
|
|
}
|
|
|
|
const idToken = authHeader.split('Bearer ')[1];
|
|
const decodedToken = await admin.auth().verifyIdToken(idToken);
|
|
const uid = decodedToken.uid;
|
|
|
|
const {
|
|
amount,
|
|
customerName,
|
|
customerEmail,
|
|
customerPhone,
|
|
productInfo
|
|
} = request.body;
|
|
|
|
if (!amount || !customerEmail || !customerPhone) {
|
|
response.status(400).json({ error: 'Missing required fields' });
|
|
return;
|
|
}
|
|
|
|
const clientId = process.env.CASHFREE_CLIENT_ID;
|
|
const clientSecret = process.env.CASHFREE_CLIENT_SECRET;
|
|
const isTest = true;
|
|
|
|
const apiUrl = isTest
|
|
? 'https://sandbox.cashfree.com/pg/orders'
|
|
: 'https://api.cashfree.com/pg/orders';
|
|
|
|
const orderId = `order_${Date.now()}_${uid.substring(0, 6)}`;
|
|
|
|
const cashfreeResponse = await axios.post(
|
|
apiUrl,
|
|
{
|
|
order_id: orderId,
|
|
order_amount: amount,
|
|
order_currency: 'INR',
|
|
customer_details: {
|
|
customer_id: uid,
|
|
customer_name: customerName || 'Fitlien User',
|
|
customer_email: customerEmail,
|
|
customer_phone: customerPhone
|
|
},
|
|
order_meta: {
|
|
return_url: `https://fitlien.com/payment/status?order_id={order_id}`,
|
|
notify_url: `https://filien.web.app/verifyCashfreePayment`
|
|
},
|
|
order_note: productInfo || 'Fitlien Membership'
|
|
},
|
|
{
|
|
headers: {
|
|
'x-api-version': '2022-09-01',
|
|
'x-client-id': clientId,
|
|
'x-client-secret': clientSecret,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
}
|
|
);
|
|
|
|
await admin.firestore().collection('payment_orders').doc(orderId).set({
|
|
userId: uid,
|
|
amount: amount,
|
|
customerEmail: customerEmail,
|
|
customerPhone: customerPhone,
|
|
orderStatus: 'CREATED',
|
|
paymentGateway: 'Cashfree',
|
|
createdAt: new Date(),
|
|
...cashfreeResponse.data
|
|
});
|
|
|
|
response.json({
|
|
order_id: cashfreeResponse.data.order_id,
|
|
payment_session_id: cashfreeResponse.data.payment_session_id
|
|
});
|
|
|
|
logger.info(`Cashfree order created: ${orderId}`);
|
|
} catch (error: any) {
|
|
logger.error('Cashfree order creation error:', error);
|
|
response.status(500).json({
|
|
error: 'Failed to create payment order',
|
|
details: error.response?.data || error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
export const verifyCashfreePayment = onRequest({
|
|
region: process.env.SERVICES_RGN
|
|
}, async (request: Request, response: express.Response) => {
|
|
try {
|
|
const orderId = request.body.order_id || request.query.order_id;
|
|
|
|
if (!orderId) {
|
|
response.status(400).json({ error: 'Order ID is required' });
|
|
return;
|
|
}
|
|
|
|
const clientId = process.env.CASHFREE_CLIENT_ID;
|
|
const clientSecret = process.env.CASHFREE_CLIENT_SECRET;
|
|
const isTest = process.env.CASHFREE_ENVIRONMENT !== 'production';
|
|
|
|
const apiUrl = isTest
|
|
? `https://sandbox.cashfree.com/pg/orders/${orderId}`
|
|
: `https://api.cashfree.com/pg/orders/${orderId}`;
|
|
|
|
const cashfreeResponse = await axios.get(
|
|
apiUrl,
|
|
{
|
|
headers: {
|
|
'x-api-version': '2022-09-01',
|
|
'x-client-id': clientId,
|
|
'x-client-secret': clientSecret
|
|
}
|
|
}
|
|
);
|
|
|
|
await admin.firestore().collection('payment_orders').doc(orderId).update({
|
|
orderStatus: cashfreeResponse.data.order_status,
|
|
paymentDetails: cashfreeResponse.data,
|
|
updatedAt: new Date()
|
|
});
|
|
|
|
if (request.headers['x-webhook-source'] === 'cashfree') {
|
|
response.status(200).send('OK');
|
|
return;
|
|
}
|
|
|
|
response.json({
|
|
status: cashfreeResponse.data.order_status,
|
|
paymentDetails: cashfreeResponse.data
|
|
});
|
|
|
|
logger.info(`Cashfree payment verified: ${orderId}`);
|
|
} catch (error: any) {
|
|
logger.error('Cashfree payment verification error:', error);
|
|
response.status(500).json({
|
|
error: 'Failed to verify payment status',
|
|
details: error.response?.data || error.message
|
|
});
|
|
}
|
|
});
|
|
|
|
export const sendFCMNotificationByType = onRequest({
|
|
region: process.env.SERVICES_RGN
|
|
}, async (request: Request, response: express.Response) => {
|
|
try {
|
|
const notificationType = request.body.type || request.query.type;
|
|
const userId = request.body.userId || request.body.clientId || request.query.userId || request.query.clientId || request.body.invitorId || request.query.invitorId;
|
|
|
|
if (!notificationType) {
|
|
response.status(400).json({ error: 'Notification type is required' });
|
|
return;
|
|
}
|
|
|
|
if (!userId) {
|
|
response.status(400).json({ error: 'User ID is required' });
|
|
return;
|
|
}
|
|
|
|
const userDoc = await admin.firestore().collection('users').doc(userId).get();
|
|
|
|
if (!userDoc.exists) {
|
|
response.status(404).json({ error: `User not found for ID: ${userId}` });
|
|
return;
|
|
}
|
|
|
|
const user = userDoc.data();
|
|
const fcmToken = user?.fcmToken;
|
|
|
|
if (!fcmToken) {
|
|
response.status(400).json({ error: `FCM token not found for user: ${userId}` });
|
|
return;
|
|
}
|
|
|
|
const userIdQuery = admin.firestore().collection('notifications')
|
|
.where('userId', '==', userId)
|
|
.where('type', '==', notificationType);
|
|
|
|
const clientIdQuery = admin.firestore().collection('notifications')
|
|
.where('clientId', '==', userId)
|
|
.where('type', '==', notificationType);
|
|
|
|
const invitorIdQuery = admin.firestore().collection('notifications')
|
|
.where('invitorId', '==', userId)
|
|
.where('type', '==', notificationType);
|
|
|
|
const [userIdResults, clientIdResults, invitorIdResults] = await Promise.all([
|
|
userIdQuery.get(),
|
|
clientIdQuery.get(),
|
|
invitorIdQuery.get()
|
|
]);
|
|
|
|
const notificationDocs = [...userIdResults.docs, ...clientIdResults.docs, ...invitorIdResults.docs]
|
|
.filter(doc => {
|
|
const data = doc.data();
|
|
return data.notificationSent !== true;
|
|
});
|
|
|
|
if (notificationDocs.length === 0) {
|
|
response.status(404).json({
|
|
error: `No unsent notifications of type '${notificationType}' found for user/client ${userId}`
|
|
});
|
|
return;
|
|
}
|
|
|
|
const results = [];
|
|
|
|
for (const doc of notificationDocs) {
|
|
const notification = doc.data();
|
|
const docId = doc.id;
|
|
if (notification.notificationSent) {
|
|
logger.info(`Notification ${notificationType} already sent, skipping.`);
|
|
continue;
|
|
}
|
|
|
|
let title = 'New Notification';
|
|
let body = notification.message || 'You have a new notification';
|
|
let data: Record<string, string> = {
|
|
type: notification.type,
|
|
};
|
|
|
|
switch (notification.type) {
|
|
case 'day_pass_entry':
|
|
const isAccepted = notification.status === 'ACCEPTED';
|
|
title = isAccepted ? 'Day Pass Approved' : 'Day Pass Denied';
|
|
body = notification.message || (isAccepted ?
|
|
`Your day pass has been approved` :
|
|
`Your day pass has been denied`);
|
|
data.gymName = notification.gymName || '';
|
|
break;
|
|
|
|
case 'trainer_assigned_to_client':
|
|
title = 'Trainer Assigned';
|
|
body = notification.message || `${notification.trainerName} has been assigned as your trainer`;
|
|
data.trainerName = notification.trainerName || '';
|
|
data.membershipId = notification.membershipId || '';
|
|
break;
|
|
|
|
case 'client_invitations':
|
|
const isAccept = notification.status === 'ACCEPTED';
|
|
title = isAccept ? 'Invitation Accepted' : 'Invitation Rejected';
|
|
body = notification.message || (isAccept ?
|
|
`The invitation for ${notification.subcriptionName} you shared with ${notification.name} has been accepted` :
|
|
`The invitation for ${notification.subcriptionName} you shared with ${notification.name} has been rejected`);
|
|
data.gymName = notification.gymName || '';
|
|
data.clientEmail = notification.clientEmail || '';
|
|
data.clientName = notification.name || '';
|
|
data.invitationId = notification.invitationId || '';
|
|
data.subcriptionname= notification.subcriptionname || '';
|
|
break;
|
|
|
|
default:
|
|
logger.info(`Using default handling for notification type: ${notification.type}`);
|
|
break;
|
|
}
|
|
|
|
const message: admin.messaging.Message = {
|
|
notification: {
|
|
title: title,
|
|
body: body,
|
|
},
|
|
data: data,
|
|
android: {
|
|
priority: 'high',
|
|
notification: {
|
|
channelId: 'notifications_channel',
|
|
priority: 'high',
|
|
defaultSound: true,
|
|
defaultVibrateTimings: true,
|
|
icon: '@mipmap/ic_launcher',
|
|
clickAction: 'FLUTTER_NOTIFICATION_CLICK',
|
|
},
|
|
},
|
|
apns: {
|
|
payload: {
|
|
aps: {
|
|
sound: 'default',
|
|
badge: 1,
|
|
},
|
|
},
|
|
},
|
|
token: fcmToken,
|
|
};
|
|
|
|
try {
|
|
const fcmResponse = await admin.messaging().send(message);
|
|
logger.info(`FCM notification sent to user ${userId} for type: ${notification.type}`);
|
|
|
|
await admin.firestore().collection('notifications').doc(docId).update({
|
|
notificationSent: true,
|
|
sentAt: admin.firestore.FieldValue?.serverTimestamp?.() || new Date()
|
|
});
|
|
|
|
results.push({
|
|
success: true,
|
|
messageId: fcmResponse
|
|
});
|
|
} catch (error) {
|
|
logger.error(`Error sending notification ${notificationType}:`, error);
|
|
results.push({
|
|
success: false,
|
|
type: notificationType,
|
|
error: error instanceof Error ? error.message : String(error)
|
|
});
|
|
}
|
|
}
|
|
|
|
response.json({
|
|
success: true,
|
|
processed: results.length,
|
|
results: results
|
|
});
|
|
|
|
} catch (error) {
|
|
logger.error('Error processing notifications:', error);
|
|
response.status(500).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : String(error)
|
|
});
|
|
}
|
|
});
|
|
|
|
export const sendFCMNotificationByPhone = onRequest({
|
|
region: process.env.SERVICES_RGN
|
|
}, async (request: Request, response: express.Response) => {
|
|
try {
|
|
const notificationType = request.body.type || request.query.type;
|
|
const phoneNumber = request.body.phoneNumber || request.query.phoneNumber;
|
|
|
|
if (!notificationType) {
|
|
response.status(400).json({ error: 'Notification type is required' });
|
|
return;
|
|
}
|
|
|
|
if (!phoneNumber) {
|
|
response.status(400).json({ error: 'Phone number is required' });
|
|
return;
|
|
}
|
|
|
|
const userQuery = await admin
|
|
.firestore()
|
|
.collection('users')
|
|
.where('phoneNumber', '==', phoneNumber)
|
|
.get();
|
|
|
|
if (userQuery.empty) {
|
|
response.status(404).json({ error: `User not found for phone number: ${phoneNumber}` });
|
|
return;
|
|
}
|
|
|
|
const userDoc = userQuery.docs[0];
|
|
const user = userDoc.data();
|
|
const fcmToken = user?.fcmToken;
|
|
|
|
if (!fcmToken) {
|
|
response.status(400).json({ error: `FCM token not found for user with phone: ${phoneNumber}` });
|
|
return;
|
|
}
|
|
|
|
const invitorIdQuery = admin.firestore().collection('notifications')
|
|
.where('phoneNumber', '==', phoneNumber)
|
|
.where('type', '==', notificationType);
|
|
|
|
const [userIdResults] = await Promise.all([
|
|
invitorIdQuery.get()
|
|
]);
|
|
|
|
const notificationDocs = [...userIdResults.docs]
|
|
.filter(doc => {
|
|
const data = doc.data();
|
|
return data.notificationSent !== true;
|
|
});
|
|
|
|
if (notificationDocs.length === 0) {
|
|
response.status(404).json({
|
|
error: `No unsent notifications of type '${notificationType}' found for user with phone ${phoneNumber}`
|
|
});
|
|
return;
|
|
}
|
|
|
|
const results = [];
|
|
|
|
for (const doc of notificationDocs) {
|
|
const notification = doc.data();
|
|
const docId = doc.id;
|
|
|
|
let title = 'New Notification';
|
|
let body = notification.message || 'You have a new notification';
|
|
let data: Record<string, string> = {
|
|
type: notification.type,
|
|
};
|
|
|
|
switch (notification.type) {
|
|
|
|
case 'client_invitations':
|
|
let invitationStatus;
|
|
if (notification.status === 'ACCEPTED') {
|
|
invitationStatus = 'accepted';
|
|
title = 'Invitation Accepted';
|
|
body = notification.message ||
|
|
`You have rejected the invitation from ${notification.name}`;
|
|
} else if (notification.status === 'REJECTED') {
|
|
invitationStatus = 'rejected';
|
|
title = 'Invitation Rejected';
|
|
body = notification.message ||
|
|
`You have rejected the invitation from ${notification.name}`;
|
|
} else if (notification.status === 'PENDING') {
|
|
invitationStatus = 'pending';
|
|
title = 'New Invitation';
|
|
body = notification.message ||
|
|
`You have a new invitation pending from ${notification.name}`;
|
|
} else {
|
|
invitationStatus = 'unknown';
|
|
title = 'Invitation Update';
|
|
body = notification.message || 'There is an update to your invitation';
|
|
}
|
|
|
|
data.gymName = notification.gymName || '';
|
|
data.clientEmail = notification.clientEmail || '';
|
|
data.clientName = notification.name || '';
|
|
data.invitationId = notification.invitationId || '';
|
|
data.subscriptionName = notification.subscriptionName || '';
|
|
data.status = invitationStatus;
|
|
break;
|
|
|
|
default:
|
|
logger.info(`Using default handling for notification type: ${notification.type}`);
|
|
break;
|
|
}
|
|
|
|
const message: admin.messaging.Message = {
|
|
notification: {
|
|
title: title,
|
|
body: body,
|
|
},
|
|
data: data,
|
|
android: {
|
|
priority: 'high',
|
|
notification: {
|
|
channelId: 'notifications_channel',
|
|
priority: 'high',
|
|
defaultSound: true,
|
|
defaultVibrateTimings: true,
|
|
icon: '@mipmap/ic_launcher',
|
|
clickAction: 'FLUTTER_NOTIFICATION_CLICK',
|
|
},
|
|
},
|
|
apns: {
|
|
payload: {
|
|
aps: {
|
|
sound: 'default',
|
|
badge: 1,
|
|
},
|
|
},
|
|
},
|
|
token: fcmToken,
|
|
};
|
|
|
|
try {
|
|
const fcmResponse = await admin.messaging().send(message);
|
|
logger.info(`FCM notification sent to user with phone ${phoneNumber} for type: ${notification.type}`);
|
|
|
|
await admin.firestore().collection('notifications').doc(docId).update({
|
|
notificationSent: true,
|
|
sentAt: admin.firestore.FieldValue?.serverTimestamp?.() || new Date()
|
|
});
|
|
|
|
results.push({
|
|
success: true,
|
|
messageId: fcmResponse
|
|
});
|
|
} catch (error) {
|
|
logger.error(`Error sending notification ${notification.type}:`, error);
|
|
results.push({
|
|
success: false,
|
|
type: notification.type,
|
|
error: error instanceof Error ? error.message : String(error)
|
|
});
|
|
}
|
|
}
|
|
|
|
response.json({
|
|
success: true,
|
|
processed: results.length,
|
|
results: results
|
|
});
|
|
|
|
} catch (error) {
|
|
logger.error('Error processing notifications by phone:', error);
|
|
response.status(500).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : String(error)
|
|
});
|
|
}
|
|
});
|
|
|
|
export const sendTrainerAssignmentNotification = onRequest({
|
|
region: process.env.SERVICES_RGN
|
|
}, async (request: Request, response: express.Response) => {
|
|
try {
|
|
const notificationType = request.body.type || request.query.type || 'trainer_assigned_to_client';
|
|
const trainerName = request.body.trainerName || request.query.trainerName;
|
|
const clientId = request.body.clientId || request.query.clientId;
|
|
const gymId = request.body.gymId || request.query.gymId;
|
|
|
|
if (!trainerName) {
|
|
response.status(400).json({ error: 'Trainer name is required' });
|
|
return;
|
|
}
|
|
|
|
if (!clientId) {
|
|
response.status(400).json({ error: 'Client ID is required' });
|
|
return;
|
|
}
|
|
|
|
if (!gymId) {
|
|
response.status(400).json({ error: 'Gym ID is required' });
|
|
return;
|
|
}
|
|
|
|
// Find the trainer by name
|
|
const trainerQuery = await admin
|
|
.firestore()
|
|
.collection('trainer_profiles')
|
|
.where('fullName', '==', trainerName)
|
|
.limit(1)
|
|
.get();
|
|
|
|
if (trainerQuery.empty) {
|
|
response.status(404).json({ error: `Trainer not found with name: ${trainerName}` });
|
|
return;
|
|
}
|
|
|
|
const trainerDoc = trainerQuery.docs[0];
|
|
const trainer = trainerDoc.data();
|
|
const trainerId = trainerDoc.id;
|
|
|
|
if (!trainer.phoneNumber) {
|
|
response.status(400).json({ error: `Phone number not found for trainer: ${trainerName}` });
|
|
return;
|
|
}
|
|
|
|
// Get client name from client collection
|
|
const clientDoc = await admin.firestore().collection('clients').doc(clientId).get();
|
|
if (!clientDoc.exists) {
|
|
response.status(404).json({ error: `Client not found with ID: ${clientId}` });
|
|
return;
|
|
}
|
|
const client = clientDoc.data();
|
|
const clientName = client?.name || client?.fullName || client?.displayName || 'A new client';
|
|
|
|
// Get gym name from gym ID
|
|
const gymDoc = await admin.firestore().collection('gyms').doc(gymId).get();
|
|
if (!gymDoc.exists) {
|
|
response.status(404).json({ error: `Gym not found with ID: ${gymId}` });
|
|
return;
|
|
}
|
|
const gym = gymDoc.data();
|
|
const gymName = gym?.name || gym?.gymName || 'your gym';
|
|
|
|
// Find the user document for the trainer using their phone number
|
|
const userQuery = await admin
|
|
.firestore()
|
|
.collection('users')
|
|
.where('phoneNumber', '==', trainer.phoneNumber)
|
|
.limit(1)
|
|
.get();
|
|
|
|
if (userQuery.empty) {
|
|
response.status(404).json({ error: `User not found for trainer with phone: ${trainer.phoneNumber}` });
|
|
return;
|
|
}
|
|
|
|
const userDoc = userQuery.docs[0];
|
|
const user = userDoc.data();
|
|
const fcmToken = user?.fcmToken;
|
|
|
|
if (!fcmToken) {
|
|
response.status(400).json({ error: `FCM token not found for trainer: ${trainerName}` });
|
|
return;
|
|
}
|
|
|
|
const notificationQuery = admin.firestore().collection('notifications')
|
|
.where('type', '==', notificationType)
|
|
.where('clientId', '==', clientId)
|
|
.where('gymId', '==', gymId)
|
|
.where('trainerName', '==', trainerName);
|
|
|
|
const notificationSnapshot = await notificationQuery.get();
|
|
|
|
const unsentNotifications = notificationSnapshot.docs.filter(doc => {
|
|
const data = doc.data();
|
|
return data.notificationSent !== true;
|
|
});
|
|
|
|
if (unsentNotifications.length === 0) {
|
|
response.status(404).json({
|
|
error: `No unsent notifications found for trainer: ${trainerName}, client: ${clientId}, gym: ${gymId}`
|
|
});
|
|
return;
|
|
}
|
|
|
|
const results = [];
|
|
|
|
for (const doc of unsentNotifications) {
|
|
const docId = doc.id;
|
|
|
|
const title = 'New Client Assignment';
|
|
const body = `You have been assigned to ${clientName} at ${gymName}`;
|
|
|
|
const data: Record<string, string> = {
|
|
type: notificationType,
|
|
trainerId: trainerId,
|
|
clientId: clientId,
|
|
clientName: clientName,
|
|
gymId: gymId,
|
|
gymName: gymName
|
|
};
|
|
|
|
const message: admin.messaging.Message = {
|
|
notification: {
|
|
title: title,
|
|
body: body,
|
|
},
|
|
data: data,
|
|
android: {
|
|
priority: 'high',
|
|
notification: {
|
|
channelId: 'notifications_channel',
|
|
priority: 'high',
|
|
defaultSound: true,
|
|
defaultVibrateTimings: true,
|
|
icon: '@mipmap/ic_launcher',
|
|
clickAction: 'FLUTTER_NOTIFICATION_CLICK',
|
|
},
|
|
},
|
|
apns: {
|
|
payload: {
|
|
aps: {
|
|
sound: 'default',
|
|
badge: 1,
|
|
},
|
|
},
|
|
},
|
|
token: fcmToken,
|
|
};
|
|
|
|
try {
|
|
const fcmResponse = await admin.messaging().send(message);
|
|
logger.info(`Trainer assignment notification sent to ${trainerName}`);
|
|
|
|
await admin.firestore().collection('notifications').doc(docId).update({
|
|
notificationSent: true,
|
|
sentAt: admin.firestore.FieldValue?.serverTimestamp?.() || new Date()
|
|
});
|
|
|
|
results.push({
|
|
success: true,
|
|
messageId: fcmResponse
|
|
});
|
|
} catch (error) {
|
|
logger.error(`Error sending trainer assignment notification:`, error);
|
|
results.push({
|
|
success: false,
|
|
type: notificationType,
|
|
error: error instanceof Error ? error.message : String(error)
|
|
});
|
|
}
|
|
}
|
|
|
|
response.json({
|
|
success: true,
|
|
processed: results.length,
|
|
results: results
|
|
});
|
|
} catch (error) {
|
|
logger.error('Error processing trainer assignment notification:', error);
|
|
response.status(500).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : String(error)
|
|
});
|
|
}
|
|
});
|