644 lines
20 KiB
TypeScript
644 lines
20 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 cors from 'cors';
|
|
import axios from "axios";
|
|
import { getStorage } from 'firebase-admin/storage';
|
|
import { onDocumentCreated } from "firebase-functions/firestore";
|
|
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();
|
|
}
|
|
|
|
const corsHandler = cors({ origin: true });
|
|
|
|
export const sendEmailWithAttachment = onRequest({
|
|
region: '#{SERVICES_RGN}#'
|
|
}, async (request: Request, response: express.Response) => {
|
|
return corsHandler(request, response, async () => {
|
|
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 accessFile = onRequest({
|
|
region: '#{SERVICES_RGN}#'
|
|
}, async (request: Request, response: express.Response) => {
|
|
return corsHandler(request, response, async () => {
|
|
|
|
try {
|
|
const filePath = request.query.path as string;
|
|
if (!filePath) {
|
|
response.status(400).send('File path is required');
|
|
return;
|
|
}
|
|
|
|
const expirationMs = 60 * 60 * 1000;
|
|
|
|
const bucket = getStorage().bucket();
|
|
const file = bucket.file(filePath);
|
|
|
|
const [exists] = await file.exists();
|
|
if (!exists) {
|
|
response.status(404).send('File not found');
|
|
return;
|
|
}
|
|
|
|
const [signedUrl] = await file.getSignedUrl({
|
|
action: 'read',
|
|
expires: Date.now() + expirationMs,
|
|
responseDisposition: `attachment; filename="${path.basename(filePath)}"`,
|
|
});
|
|
|
|
response.redirect(signedUrl);
|
|
logger.info(`File access redirect for ${filePath}`);
|
|
} catch (error) {
|
|
logger.error('Error accessing file:', error);
|
|
response.status(500).send('Error accessing file');
|
|
}
|
|
});
|
|
});
|
|
|
|
export const sendEmailMessage = onRequest({
|
|
region: '#{SERVICES_RGN}#'
|
|
}, (request: Request, response: express.Response) => {
|
|
return corsHandler(request, response, async () => {
|
|
|
|
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: '#{SERVICES_RGN}#'
|
|
}, (request: Request, response: express.Response) => {
|
|
return corsHandler(request, response, async () => {
|
|
|
|
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 processNotificationOnCreate = onDocumentCreated({
|
|
region: '#{SERVICES_RGN}#',
|
|
document: 'notifications/{notificationId}'
|
|
}, async (event) => {
|
|
try {
|
|
const notification = event.data?.data();
|
|
const notificationId = event.params.notificationId;
|
|
|
|
if (!notification) {
|
|
logger.error(`No data found for notification ${notificationId}`);
|
|
return;
|
|
}
|
|
|
|
if (notification.notificationSent === true) {
|
|
logger.info(`Notification ${notificationId} already sent, skipping.`);
|
|
return;
|
|
}
|
|
|
|
let userId = null;
|
|
let fcmToken = null;
|
|
|
|
if (notification.userId) {
|
|
userId = notification.userId;
|
|
const userDoc = await admin.firestore().collection('users').doc(userId).get();
|
|
if (userDoc.exists) {
|
|
fcmToken = userDoc.data()?.fcmToken;
|
|
}
|
|
} else if (notification.clientId) {
|
|
userId = notification.clientId;
|
|
const userDoc = await admin.firestore().collection('users').doc(userId).get();
|
|
if (userDoc.exists) {
|
|
fcmToken = userDoc.data()?.fcmToken;
|
|
}
|
|
} else if (notification.invitorId) {
|
|
userId = notification.invitorId;
|
|
const userDoc = await admin.firestore().collection('users').doc(userId).get();
|
|
if (userDoc.exists) {
|
|
fcmToken = userDoc.data()?.fcmToken;
|
|
}
|
|
} else if (notification.phoneNumber) {
|
|
const userQuery = await admin
|
|
.firestore()
|
|
.collection('users')
|
|
.where('phoneNumber', '==', notification.phoneNumber)
|
|
.limit(1)
|
|
.get();
|
|
|
|
if (!userQuery.empty) {
|
|
const userDoc = userQuery.docs[0];
|
|
userId = userDoc.id;
|
|
fcmToken = userDoc.data()?.fcmToken;
|
|
}
|
|
}
|
|
|
|
if (!fcmToken) {
|
|
logger.error(`FCM token not found for notification ${notificationId}`);
|
|
await admin.firestore().collection('notifications').doc(notificationId).update({
|
|
notificationError: 'FCM token not found for user',
|
|
updatedAt: admin.firestore.FieldValue?.serverTimestamp?.() || new Date()
|
|
});
|
|
return;
|
|
}
|
|
|
|
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':
|
|
if (notification.userId || notification.invitorId) {
|
|
const isAccept = notification.status === 'ACCEPTED';
|
|
title = isAccept ? 'Invitation Accepted' : 'Invitation Rejected';
|
|
body = notification.message || (isAccept ?
|
|
`The invitation for ${notification.subscriptionName} you shared with ${notification.name} has been accepted` :
|
|
`The invitation for ${notification.subscriptionName} you shared with ${notification.name} has been rejected`);
|
|
} else if (notification.phoneNumber) {
|
|
let invitationStatus;
|
|
if (notification.status === 'ACCEPTED') {
|
|
invitationStatus = 'accepted';
|
|
title = 'Invitation Accepted';
|
|
body = notification.message ||
|
|
`You have accepted 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.status = invitationStatus;
|
|
}
|
|
|
|
data.gymName = notification.gymName || '';
|
|
data.clientEmail = notification.clientEmail || '';
|
|
data.clientName = notification.name || '';
|
|
data.invitationId = notification.invitationId || '';
|
|
data.subscriptionName = notification.subscriptionName || '';
|
|
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 successfully: ${fcmResponse}`);
|
|
|
|
await admin.firestore().collection('notifications').doc(notificationId).update({
|
|
notificationSent: true,
|
|
sentAt: admin.firestore.FieldValue?.serverTimestamp?.() || new Date()
|
|
});
|
|
} catch (error) {
|
|
logger.error(`Error sending notification ${notificationId}:`, error);
|
|
|
|
await admin.firestore().collection('notifications').doc(notificationId).update({
|
|
notificationError: error instanceof Error ? error.message : String(error),
|
|
updatedAt: admin.firestore.FieldValue?.serverTimestamp?.() || new Date()
|
|
});
|
|
}
|
|
} catch (error) {
|
|
logger.error('Error processing notification:', error);
|
|
}
|
|
});
|
|
|
|
export const createCashfreeOrder = onRequest({
|
|
region: '#{SERVICES_RGN}#'
|
|
}, async (request: Request, response: express.Response) => {
|
|
|
|
return corsHandler(request, response, async () => {
|
|
try {
|
|
const authHeader = request.headers.authorization;
|
|
if (!authHeader || !authHeader.startsWith('Bearer ')) {
|
|
response.status(401).json({ error: 'Unauthorized' });
|
|
return;
|
|
}
|
|
|
|
const idToken = authHeader.split('Bearer ')[1];
|
|
try {
|
|
const decodedToken = await admin.auth().verifyIdToken(idToken);
|
|
const uid = decodedToken.uid;
|
|
|
|
const {
|
|
amount,
|
|
customerName,
|
|
customerEmail,
|
|
customerPhone,
|
|
productInfo,
|
|
userId,
|
|
gymId,
|
|
orderId,
|
|
webHostUrl,
|
|
} = 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;
|
|
|
|
if (!clientId || !clientSecret) {
|
|
logger.error('Cashfree credentials not configured');
|
|
response.status(500).json({ error: 'Payment gateway configuration error' });
|
|
return;
|
|
}
|
|
|
|
const hashKey = `hash_${Date.now()}_${uid.substring(0, 1)}_${orderId}`;
|
|
let apiUrl = process.env.CASHFREE_URL;
|
|
try {
|
|
const cashfreeResponse = await axios.post(
|
|
apiUrl!,
|
|
{
|
|
order_id: orderId,
|
|
hash_key: hashKey,
|
|
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://${webHostUrl}?order_id=${orderId}&hash_key=${hashKey}&user_id=${userId}&gym_id=${gymId}#/payment-status-screen`,
|
|
},
|
|
order_note: productInfo || 'Fitlien Membership'
|
|
},
|
|
{
|
|
headers: {
|
|
'x-api-version': '2022-09-01',
|
|
'x-client-id': clientId,
|
|
'x-client-secret': clientSecret,
|
|
'Content-Type': 'application/json'
|
|
}
|
|
}
|
|
);
|
|
|
|
try {
|
|
await admin.firestore().collection('payment_orders').doc(orderId).set({
|
|
userId: uid,
|
|
amount: amount,
|
|
customerEmail: customerEmail,
|
|
customerPhone: customerPhone,
|
|
orderStatus: 'CREATED',
|
|
paymentGateway: 'Cashfree',
|
|
createdAt: new Date(),
|
|
hashKey: hashKey,
|
|
clientId: userId,
|
|
gymId: gymId,
|
|
orderId: orderId,
|
|
...cashfreeResponse.data
|
|
});
|
|
} catch (firestoreError) {
|
|
logger.error('Error storing order in Firestore:', firestoreError);
|
|
}
|
|
|
|
response.json({
|
|
success: true,
|
|
order_id: cashfreeResponse.data.order_id,
|
|
payment_session_id: cashfreeResponse.data.payment_session_id
|
|
});
|
|
|
|
logger.info(`Cashfree order created: ${orderId}`);
|
|
} catch (axiosError: any) {
|
|
logger.error('Cashfree API error:', axiosError);
|
|
response.status(axiosError.response?.status || 500).json({
|
|
success: false,
|
|
error: 'Payment gateway error',
|
|
details: axiosError.response?.data || axiosError.message,
|
|
code: axiosError.code
|
|
});
|
|
}
|
|
} catch (authError) {
|
|
logger.error('Authentication error:', authError);
|
|
response.status(401).json({
|
|
success: false,
|
|
error: 'Invalid authentication token'
|
|
});
|
|
}
|
|
} catch (error: any) {
|
|
logger.error('Cashfree order creation error:', error);
|
|
response.status(500).json({
|
|
success: false,
|
|
error: 'Failed to create payment order',
|
|
details: error.message
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
|
|
export const verifyCashfreePayment = onRequest({
|
|
region: '#{SERVICES_RGN}#'
|
|
}, async (request: Request, response: express.Response) => {
|
|
return corsHandler(request, response, async () => {
|
|
|
|
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 apiUrl = process.env.CASHFREE_URL;
|
|
|
|
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 getPlacesAutocomplete = onRequest({
|
|
region: '#{SERVICES_RGN}#'
|
|
}, async (request: Request, response: express.Response) => {
|
|
return corsHandler(request, response, async () => {
|
|
try {
|
|
const { input, location, radius, types, components, sessiontoken } = request.query;
|
|
|
|
if (!input) {
|
|
response.status(400).json({
|
|
error: 'Input parameter is required for autocomplete'
|
|
});
|
|
return;
|
|
}
|
|
|
|
const apiKey = process.env.GOOGLE_MAPS_API_KEY;
|
|
if (!apiKey) {
|
|
logger.error('Google Places API key is not configured');
|
|
response.status(500).json({ error: 'Server configuration error' });
|
|
return;
|
|
}
|
|
|
|
const url = 'https://maps.googleapis.com/maps/api/place/autocomplete/json';
|
|
const params: any = {
|
|
key: apiKey,
|
|
input: input
|
|
};
|
|
|
|
if (location && radius) {
|
|
params.location = location;
|
|
params.radius = radius;
|
|
}
|
|
|
|
if (types) {
|
|
params.types = types;
|
|
}
|
|
|
|
if (components) {
|
|
params.components = components;
|
|
}
|
|
|
|
if (sessiontoken) {
|
|
params.sessiontoken = sessiontoken;
|
|
}
|
|
|
|
const result = await axios.get(url, { params });
|
|
|
|
logger.info('Google Places Autocomplete API request completed successfully');
|
|
response.json(result.data);
|
|
} catch (error) {
|
|
logger.error('Error fetching place autocomplete suggestions:', error);
|
|
response.status(500).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : String(error)
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
export const getPlaceDetails = onRequest({
|
|
region: '#{SERVICES_RGN}#'
|
|
}, async (request: Request, response: express.Response) => {
|
|
return corsHandler(request, response, async () => {
|
|
try {
|
|
const { place_id, fields } = request.query;
|
|
|
|
if (!place_id) {
|
|
response.status(400).json({
|
|
error: 'place_id parameter is required'
|
|
});
|
|
return;
|
|
}
|
|
|
|
const apiKey = process.env.GOOGLE_MAPS_API_KEY;
|
|
if (!apiKey) {
|
|
logger.error('Google Places API key is not configured');
|
|
response.status(500).json({ error: 'Server configuration error' });
|
|
return;
|
|
}
|
|
|
|
const url = 'https://maps.googleapis.com/maps/api/place/details/json';
|
|
const params: any = {
|
|
key: apiKey,
|
|
place_id: place_id,
|
|
fields: fields || 'geometry'
|
|
};
|
|
|
|
const result = await axios.get(url, { params });
|
|
logger.info('Google Places Details API request completed successfully');
|
|
response.json(result.data);
|
|
} catch (error) {
|
|
logger.error('Error fetching place details:', error);
|
|
response.status(500).json({
|
|
success: false,
|
|
error: error instanceof Error ? error.message : String(error)
|
|
});
|
|
}
|
|
});
|
|
});
|