vodorod/parcer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: google integration auth notif

Browse Source
This commit is contained in:
RohitR311
2024-11-13 00:05:01 +05:30
parent 9027435c70
commit 8e039fea01
1 changed files with 441 additions and 367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

808
server/src/routes/auth.ts
View File

@@ -1,490 +1,564 @@
import { Router, Request, Response } from 'express'; import { Router, Request, Response } from "express";
import User from '../models/User'; import User from "../models/User";
import Robot from '../models/Robot'; import Robot from "../models/Robot";
import jwt from 'jsonwebtoken'; import jwt from "jsonwebtoken";
import { hashPassword, comparePassword } from '../utils/auth'; import { hashPassword, comparePassword } from "../utils/auth";
import { requireSignIn } from '../middlewares/auth'; import { requireSignIn } from "../middlewares/auth";
import { genAPIKey } from '../utils/api'; import { genAPIKey } from "../utils/api";
import { google } from 'googleapis'; import { google } from "googleapis";
import { capture } from "../utils/analytics" import { capture } from "../utils/analytics";
export const router = Router(); export const router = Router();
interface AuthenticatedRequest extends Request { interface AuthenticatedRequest extends Request {
user?: { id: string }; user?: { id: string };
} }
router.post('/register', async (req, res) => { router.post("/register", async (req, res) => {
console.log('Received request at /auth/register'); console.log("Received request at /auth/register");
try {
const { email, password } = req.body;
if (!email) return res.status(400).send("Email is required");
if (!password || password.length < 6)
return res
.status(400)
.send("Password is required and must be at least 6 characters");
let userExist = await User.findOne({ raw: true, where: { email } });
if (userExist) return res.status(400).send("User already exists");
const hashedPassword = await hashPassword(password);
let user: any;
try { try {
const { email, password } = req.body user = await User.create({ email, password: hashedPassword });
if (!email) return res.status(400).send('Email is required')
if (!password || password.length < 6) return res.status(400).send('Password is required and must be at least 6 characters')
let userExist = await User.findOne({ raw: true, where: { email } });
if (userExist) return res.status(400).send('User already exists')
const hashedPassword = await hashPassword(password)
let user: any;
try {
user = await User.create({ email, password: hashedPassword });
} catch (
error: any
) {
console.log(`Could not create user - ${error}`)
return res.status(500).send(`Could not create user - ${error.message}`)
}
if (!process.env.JWT_SECRET) {
console.log('JWT_SECRET is not defined in the environment');
return res.status(500).send('Internal Server Error');
}
const token = jwt.sign({ id: user.id }, process.env.JWT_SECRET as string, { expiresIn: '12h' });
user.password = undefined as unknown as string
res.cookie('token', token, {
httpOnly: true
})
capture(
'maxun-oss-user-registered',
{
email: user.email,
userId: user.id,
registeredAt: new Date().toISOString()
}
)
console.log(`User registered - ${user.email}`)
res.json(user)
} catch (error: any) { } catch (error: any) {
console.log(`Could not register user - ${error}`) console.log(`Could not create user - ${error}`);
res.status(500).send(`Could not register user - ${error.message}`) return res.status(500).send(`Could not create user - ${error.message}`);
} }
})
router.post('/login', async (req, res) => { if (!process.env.JWT_SECRET) {
try { console.log("JWT_SECRET is not defined in the environment");
const { email, password } = req.body; return res.status(500).send("Internal Server Error");
if (!email || !password) return res.status(400).send('Email and password are required')
if (password.length < 6) return res.status(400).send('Password must be at least 6 characters')
let user = await User.findOne({ raw: true, where: { email } });
if (!user) return res.status(400).send('User does not exist');
const match = await comparePassword(password, user.password)
if (!match) return res.status(400).send('Invalid email or password')
const token = jwt.sign({ id: user?.id }, process.env.JWT_SECRET as string, { expiresIn: '12h' });
// return user and token to client, exclude hashed password
if (user) {
user.password = undefined as unknown as string;
}
res.cookie('token', token, {
httpOnly: true
})
capture(
'maxun-oss-user-login',
{
email: user.email,
userId: user.id,
loggedInAt: new Date().toISOString()
}
)
res.json(user)
} catch (error: any) {
res.status(400).send(`Could not login user - ${error.message}`)
console.log(`Could not login user - ${error}`)
} }
})
router.get('/logout', async (req, res) => { const token = jwt.sign({ id: user.id }, process.env.JWT_SECRET as string, {
try { expiresIn: "12h",
res.clearCookie('token') });
return res.json({ message: 'Logout successful' }) user.password = undefined as unknown as string;
} catch (error: any) { res.cookie("token", token, {
res.status(500).send(`Could not logout user - ${error.message}`) httpOnly: true,
} });
}) capture("maxun-oss-user-registered", {
email: user.email,
router.get('/current-user', requireSignIn, async (req: AuthenticatedRequest, res) => { userId: user.id,
try { registeredAt: new Date().toISOString(),
if (!req.user) { });
return res.status(401).json({ ok: false, error: 'Unauthorized' }); console.log(`User registered - ${user.email}`);
} res.json(user);
const user = await User.findByPk(req.user.id, { } catch (error: any) {
attributes: { exclude: ['password'] }, console.log(`Could not register user - ${error}`);
}); res.status(500).send(`Could not register user - ${error.message}`);
if (!user) { }
return res.status(404).json({ ok: false, error: 'User not found' });
} else {
return res.status(200).json({ ok: true, user: user });
}
} catch (error: any) {
console.error('Error in current-user route:', error);
return res.status(500).json({ ok: false, error: `Could not fetch current user: ${error.message}` });
}
}); });
router.get('/user/:id', requireSignIn, async (req: AuthenticatedRequest, res) => { router.post("/login", async (req, res) => {
try { try {
const { id } = req.params; const { email, password } = req.body;
if (!id) { if (!email || !password)
return res.status(400).json({ message: 'User ID is required' }); return res.status(400).send("Email and password are required");
} if (password.length < 6)
return res.status(400).send("Password must be at least 6 characters");
const user = await User.findByPk(id, { let user = await User.findOne({ raw: true, where: { email } });
attributes: { exclude: ['password'] }, if (!user) return res.status(400).send("User does not exist");
});
if (!user) { const match = await comparePassword(password, user.password);
return res.status(404).json({ message: 'User not found' }); if (!match) return res.status(400).send("Invalid email or password");
}
return res.status(200).json({ message: 'User fetched successfully', user }); const token = jwt.sign({ id: user?.id }, process.env.JWT_SECRET as string, {
} catch (error: any) { expiresIn: "12h",
return res.status(500).json({ message: 'Error fetching user', error: error.message }); });
// return user and token to client, exclude hashed password
if (user) {
user.password = undefined as unknown as string;
} }
res.cookie("token", token, {
httpOnly: true,
});
capture("maxun-oss-user-login", {
email: user.email,
userId: user.id,
loggedInAt: new Date().toISOString(),
});
res.json(user);
} catch (error: any) {
res.status(400).send(`Could not login user - ${error.message}`);
console.log(`Could not login user - ${error}`);
}
}); });
router.post('/generate-api-key', requireSignIn, async (req: AuthenticatedRequest, res) => { router.get("/logout", async (req, res) => {
try {
res.clearCookie("token");
return res.json({ message: "Logout successful" });
} catch (error: any) {
res.status(500).send(`Could not logout user - ${error.message}`);
}
});
router.get(
"/current-user",
requireSignIn,
async (req: AuthenticatedRequest, res) => {
try { try {
if (!req.user) { if (!req.user) {
return res.status(401).json({ ok: false, error: 'Unauthorized' }); return res.status(401).json({ ok: false, error: "Unauthorized" });
} }
const user = await User.findByPk(req.user.id, { const user = await User.findByPk(req.user.id, {
attributes: { exclude: ['password'] }, attributes: { exclude: ["password"] },
});
if (!user) {
return res.status(404).json({ ok: false, error: "User not found" });
} else {
return res.status(200).json({ ok: true, user: user });
}
} catch (error: any) {
console.error("Error in current-user route:", error);
return res
.status(500)
.json({
ok: false,
error: `Could not fetch current user: ${error.message}`,
}); });
}
}
);
if (!user) { router.get(
return res.status(404).json({ message: 'User not found' }); "/user/:id",
} requireSignIn,
async (req: AuthenticatedRequest, res) => {
try {
const { id } = req.params;
if (!id) {
return res.status(400).json({ message: "User ID is required" });
}
if (user.api_key) { const user = await User.findByPk(id, {
return res.status(400).json({ message: 'API key already exists' }); attributes: { exclude: ["password"] },
} });
const apiKey = genAPIKey();
await user.update({ api_key: apiKey }); if (!user) {
return res.status(404).json({ message: "User not found" });
}
capture( return res
'maxun-oss-api-key-created', .status(200)
{ .json({ message: "User fetched successfully", user });
user_id: user.id, } catch (error: any) {
created_at: new Date().toISOString() return res
} .status(500)
) .json({ message: "Error fetching user", error: error.message });
}
}
);
return res.status(200).json({ router.post(
message: 'API key generated successfully', "/generate-api-key",
api_key: apiKey, requireSignIn,
}); async (req: AuthenticatedRequest, res) => {
try {
if (!req.user) {
return res.status(401).json({ ok: false, error: "Unauthorized" });
}
const user = await User.findByPk(req.user.id, {
attributes: { exclude: ["password"] },
});
if (!user) {
return res.status(404).json({ message: "User not found" });
}
if (user.api_key) {
return res.status(400).json({ message: "API key already exists" });
}
const apiKey = genAPIKey();
await user.update({ api_key: apiKey });
capture("maxun-oss-api-key-created", {
user_id: user.id,
created_at: new Date().toISOString(),
});
return res.status(200).json({
message: "API key generated successfully",
api_key: apiKey,
});
} catch (error) { } catch (error) {
return res.status(500).json({ message: 'Error generating API key', error }); return res
.status(500)
.json({ message: "Error generating API key", error });
} }
}); }
);
router.get('/api-key', requireSignIn, async (req: AuthenticatedRequest, res) => { router.get(
"/api-key",
requireSignIn,
async (req: AuthenticatedRequest, res) => {
try { try {
if (!req.user) { if (!req.user) {
return res.status(401).json({ ok: false, error: 'Unauthorized' }); return res.status(401).json({ ok: false, error: "Unauthorized" });
} }
const user = await User.findByPk(req.user.id, { const user = await User.findByPk(req.user.id, {
raw: true, raw: true,
attributes: ['api_key'], attributes: ["api_key"],
}); });
if (!user) { if (!user) {
return res.status(404).json({ message: 'User not found' }); return res.status(404).json({ message: "User not found" });
} }
return res.status(200).json({ return res.status(200).json({
message: 'API key fetched successfully', message: "API key fetched successfully",
api_key: user.api_key || null, api_key: user.api_key || null,
}); });
} catch (error) { } catch (error) {
return res.status(500).json({ message: 'Error fetching API key', error }); return res.status(500).json({ message: "Error fetching API key", error });
} }
}); }
);
router.delete('/delete-api-key', requireSignIn, async (req: AuthenticatedRequest, res) => {
router.delete(
"/delete-api-key",
requireSignIn,
async (req: AuthenticatedRequest, res) => {
if (!req.user) { if (!req.user) {
return res.status(401).send({ error: 'Unauthorized' }); return res.status(401).send({ error: "Unauthorized" });
} }
try { try {
const user = await User.findByPk(req.user.id, { raw: true }); const user = await User.findByPk(req.user.id, { raw: true });
if (!user) { if (!user) {
return res.status(404).json({ message: 'User not found' }); return res.status(404).json({ message: "User not found" });
} }
if (!user.api_key) { if (!user.api_key) {
return res.status(404).json({ message: 'API Key not found' }); return res.status(404).json({ message: "API Key not found" });
} }
await User.update({ api_key: null }, { where: { id: req.user.id } }); await User.update({ api_key: null }, { where: { id: req.user.id } });
capture( capture("maxun-oss-api-key-deleted", {
'maxun-oss-api-key-deleted', user_id: user.id,
{ deleted_at: new Date().toISOString(),
user_id: user.id, });
deleted_at: new Date().toISOString()
}
)
return res.status(200).json({ message: 'API Key deleted successfully' }); return res.status(200).json({ message: "API Key deleted successfully" });
} catch (error: any) { } catch (error: any) {
return res.status(500).json({ message: 'Error deleting API key', error: error.message }); return res
.status(500)
.json({ message: "Error deleting API key", error: error.message });
} }
}); }
);
const oauth2Client = new google.auth.OAuth2( const oauth2Client = new google.auth.OAuth2(
process.env.GOOGLE_CLIENT_ID, process.env.GOOGLE_CLIENT_ID,
process.env.GOOGLE_CLIENT_SECRET, process.env.GOOGLE_CLIENT_SECRET,
process.env.GOOGLE_REDIRECT_URI process.env.GOOGLE_REDIRECT_URI
); );
// Step 1: Redirect to Google for authentication // Step 1: Redirect to Google for authentication
router.get('/google', (req, res) => { router.get("/google", (req, res) => {
const { robotId } = req.query; const { robotId } = req.query;
if (!robotId) { if (!robotId) {
return res.status(400).json({ message: 'Robot ID is required' }); return res.status(400).json({ message: "Robot ID is required" });
} }
const scopes = [ const scopes = [
'https://www.googleapis.com/auth/spreadsheets', "https://www.googleapis.com/auth/spreadsheets",
'https://www.googleapis.com/auth/userinfo.email', "https://www.googleapis.com/auth/userinfo.email",
'https://www.googleapis.com/auth/drive.readonly', "https://www.googleapis.com/auth/drive.readonly",
]; ];
const url = oauth2Client.generateAuthUrl({ const url = oauth2Client.generateAuthUrl({
access_type: 'offline', access_type: "offline",
prompt: 'consent', // Ensures you get a refresh token on first login prompt: "consent", // Ensures you get a refresh token on first login
scope: scopes, scope: scopes,
state: robotId.toString(), state: robotId.toString(),
}); });
res.redirect(url); res.redirect(url);
}); });
// Step 2: Handle Google OAuth callback // Step 2: Handle Google OAuth callback
router.get('/google/callback', requireSignIn, async (req: AuthenticatedRequest, res) => { router.get(
"/google/callback",
requireSignIn,
async (req: AuthenticatedRequest, res) => {
const { code, state } = req.query; const { code, state } = req.query;
try { try {
if (!state) { if (!state) {
return res.status(400).json({ message: 'Robot ID is required' }); return res.status(400).json({ message: "Robot ID is required" });
} }
const robotId = state const robotId = state;
// Get access and refresh tokens // Get access and refresh tokens
if (typeof code !== 'string') { if (typeof code !== "string") {
return res.status(400).json({ message: 'Invalid code' }); return res.status(400).json({ message: "Invalid code" });
} }
const { tokens } = await oauth2Client.getToken(code); const { tokens } = await oauth2Client.getToken(code);
oauth2Client.setCredentials(tokens); oauth2Client.setCredentials(tokens);
// Get user profile from Google // Get user profile from Google
const oauth2 = google.oauth2({ version: 'v2', auth: oauth2Client }); const oauth2 = google.oauth2({ version: "v2", auth: oauth2Client });
const { data: { email } } = await oauth2.userinfo.get(); const {
data: { email },
} = await oauth2.userinfo.get();
if (!email) { if (!email) {
return res.status(400).json({ message: 'Email not found' }); return res.status(400).json({ message: "Email not found" });
} }
if (!req.user) { if (!req.user) {
return res.status(401).send({ error: 'Unauthorized' }); return res.status(401).send({ error: "Unauthorized" });
} }
// Get the currently authenticated user (from `requireSignIn`) // Get the currently authenticated user (from `requireSignIn`)
let user = await User.findOne({ where: { id: req.user.id } }); let user = await User.findOne({ where: { id: req.user.id } });
if (!user) { if (!user) {
return res.status(400).json({ message: 'User not found' }); return res.status(400).json({ message: "User not found" });
} }
let robot = await Robot.findOne({ where: { 'recording_meta.id': robotId } }); let robot = await Robot.findOne({
where: { "recording_meta.id": robotId },
});
if (!robot) { if (!robot) {
return res.status(400).json({ message: 'Robot not found' }); return res.status(400).json({ message: "Robot not found" });
} }
robot = await robot.update({ robot = await robot.update({
google_sheet_email: email, google_sheet_email: email,
google_access_token: tokens.access_token, google_access_token: tokens.access_token,
google_refresh_token: tokens.refresh_token, google_refresh_token: tokens.refresh_token,
}); });
capture( capture("maxun-oss-google-sheet-integration-created", {
'maxun-oss-google-sheet-integration-created', user_id: user.id,
{ robot_id: robot.recording_meta.id,
user_id: user.id, created_at: new Date().toISOString(),
robot_id: robot.recording_meta.id, });
created_at: new Date().toISOString()
}
)
// List user's Google Sheets from their Google Drive // List user's Google Sheets from their Google Drive
const drive = google.drive({ version: 'v3', auth: oauth2Client }); const drive = google.drive({ version: "v3", auth: oauth2Client });
const response = await drive.files.list({ const response = await drive.files.list({
q: "mimeType='application/vnd.google-apps.spreadsheet'", // List only Google Sheets files q: "mimeType='application/vnd.google-apps.spreadsheet'", // List only Google Sheets files
fields: 'files(id, name)', // Retrieve the ID and name of each file fields: "files(id, name)", // Retrieve the ID and name of each file
}); });
const files = response.data.files || []; const files = response.data.files || [];
if (files.length === 0) { if (files.length === 0) {
return res.status(404).json({ message: 'No spreadsheets found.' }); return res.status(404).json({ message: "No spreadsheets found." });
} }
// Generate JWT token for session // Generate JWT token for session
const jwtToken = jwt.sign({ userId: user.id }, process.env.JWT_SECRET as string, { expiresIn: '12h' }); const jwtToken = jwt.sign(
res.cookie('token', jwtToken, { httpOnly: true }); { userId: user.id },
process.env.JWT_SECRET as string,
{ expiresIn: "12h" }
);
res.cookie("token", jwtToken, { httpOnly: true });
// res.json({ // res.json({
// message: 'Google authentication successful', // message: 'Google authentication successful',
// google_sheet_email: robot.google_sheet_email, // google_sheet_email: robot.google_sheet_email,
// jwtToken, // jwtToken,
// files // files
// }); // });
res.redirect(`http://localhost:5173`); res.cookie("robot_auth_status", "success", {
httpOnly: false,
maxAge: 60000,
}); // 1-minute expiration
res.cookie("robot_auth_message", "Robot successfully authenticated", {
httpOnly: false,
maxAge: 60000,
});
res.redirect(`http://localhost:5173`);
} catch (error: any) { } catch (error: any) {
res.status(500).json({ message: `Google OAuth error: ${error.message}` }); res.status(500).json({ message: `Google OAuth error: ${error.message}` });
} }
}); }
);
// Step 3: Get data from Google Sheets // Step 3: Get data from Google Sheets
router.post('/gsheets/data', requireSignIn, async (req: AuthenticatedRequest, res) => { router.post(
"/gsheets/data",
requireSignIn,
async (req: AuthenticatedRequest, res) => {
const { spreadsheetId, robotId } = req.body; const { spreadsheetId, robotId } = req.body;
if (!req.user) { if (!req.user) {
return res.status(401).send({ error: 'Unauthorized' }); return res.status(401).send({ error: "Unauthorized" });
} }
const user = await User.findByPk(req.user.id, { raw: true }); const user = await User.findByPk(req.user.id, { raw: true });
if (!user) { if (!user) {
return res.status(400).json({ message: 'User not found' }); return res.status(400).json({ message: "User not found" });
} }
const robot = await Robot.findOne({ where: { 'recording_meta.id': robotId }, raw: true }); const robot = await Robot.findOne({
where: { "recording_meta.id": robotId },
raw: true,
});
if (!robot) { if (!robot) {
return res.status(400).json({ message: 'Robot not found' }); return res.status(400).json({ message: "Robot not found" });
} }
// Set Google OAuth credentials // Set Google OAuth credentials
oauth2Client.setCredentials({ oauth2Client.setCredentials({
access_token: robot.google_access_token, access_token: robot.google_access_token,
refresh_token: robot.google_refresh_token, refresh_token: robot.google_refresh_token,
}); });
const sheets = google.sheets({ version: 'v4', auth: oauth2Client }); const sheets = google.sheets({ version: "v4", auth: oauth2Client });
try { try {
// Fetch data from the spreadsheet (you can let the user choose a specific range too) // Fetch data from the spreadsheet (you can let the user choose a specific range too)
const sheetData = await sheets.spreadsheets.values.get({ const sheetData = await sheets.spreadsheets.values.get({
spreadsheetId, spreadsheetId,
range: 'Sheet1!A1:D5', // Default range, could be dynamic based on user input range: "Sheet1!A1:D5", // Default range, could be dynamic based on user input
}); });
res.json(sheetData.data); res.json(sheetData.data);
} catch (error: any) { } catch (error: any) {
res.status(500).json({ message: `Error accessing Google Sheets: ${error.message}` }); res
.status(500)
.json({ message: `Error accessing Google Sheets: ${error.message}` });
} }
}); }
);
// Step 4: Get user's Google Sheets files (new route) // Step 4: Get user's Google Sheets files (new route)
router.get('/gsheets/files', requireSignIn, async (req, res) => { router.get("/gsheets/files", requireSignIn, async (req, res) => {
try { try {
const robotId = req.query.robotId; const robotId = req.query.robotId;
const robot = await Robot.findOne({ where: { 'recording_meta.id': robotId }, raw: true }); const robot = await Robot.findOne({
where: { "recording_meta.id": robotId },
raw: true,
});
if (!robot) { if (!robot) {
return res.status(400).json({ message: 'Robot not found' }); return res.status(400).json({ message: "Robot not found" });
}
oauth2Client.setCredentials({
access_token: robot.google_access_token,
refresh_token: robot.google_refresh_token,
});
// List user's Google Sheets files from their Google Drive
const drive = google.drive({ version: 'v3', auth: oauth2Client });
const response = await drive.files.list({
q: "mimeType='application/vnd.google-apps.spreadsheet'",
fields: 'files(id, name)',
});
const files = response.data.files || [];
if (files.length === 0) {
return res.status(404).json({ message: 'No spreadsheets found.' });
}
res.json(files);
} catch (error: any) {
console.log('Error fetching Google Sheets files:', error);
res.status(500).json({ message: `Error retrieving Google Sheets files: ${error.message}` });
} }
oauth2Client.setCredentials({
access_token: robot.google_access_token,
refresh_token: robot.google_refresh_token,
});
// List user's Google Sheets files from their Google Drive
const drive = google.drive({ version: "v3", auth: oauth2Client });
const response = await drive.files.list({
q: "mimeType='application/vnd.google-apps.spreadsheet'",
fields: "files(id, name)",
});
const files = response.data.files || [];
if (files.length === 0) {
return res.status(404).json({ message: "No spreadsheets found." });
}
res.json(files);
} catch (error: any) {
console.log("Error fetching Google Sheets files:", error);
res
.status(500)
.json({
message: `Error retrieving Google Sheets files: ${error.message}`,
});
}
}); });
// Step 5: Update robot's google_sheet_id when a Google Sheet is selected // Step 5: Update robot's google_sheet_id when a Google Sheet is selected
router.post('/gsheets/update', requireSignIn, async (req, res) => { router.post("/gsheets/update", requireSignIn, async (req, res) => {
const { spreadsheetId, spreadsheetName, robotId } = req.body; const { spreadsheetId, spreadsheetName, robotId } = req.body;
if (!spreadsheetId || !robotId) { if (!spreadsheetId || !robotId) {
return res.status(400).json({ message: 'Spreadsheet ID and Robot ID are required' }); return res
.status(400)
.json({ message: "Spreadsheet ID and Robot ID are required" });
}
try {
let robot = await Robot.findOne({
where: { "recording_meta.id": robotId },
});
if (!robot) {
return res.status(404).json({ message: "Robot not found" });
} }
try { await robot.update({
let robot = await Robot.findOne({ where: { 'recording_meta.id': robotId } }); google_sheet_id: spreadsheetId,
google_sheet_name: spreadsheetName,
});
if (!robot) { res.json({ message: "Robot updated with selected Google Sheet ID" });
return res.status(404).json({ message: 'Robot not found' }); } catch (error: any) {
} res.status(500).json({ message: `Error updating robot: ${error.message}` });
}
await robot.update({ google_sheet_id: spreadsheetId, google_sheet_name: spreadsheetName });
res.json({ message: 'Robot updated with selected Google Sheet ID' });
} catch (error: any) {
res.status(500).json({ message: `Error updating robot: ${error.message}` });
}
}); });
router.post('/gsheets/remove', requireSignIn, async (req: AuthenticatedRequest, res) => { router.post(
"/gsheets/remove",
requireSignIn,
async (req: AuthenticatedRequest, res) => {
const { robotId } = req.body; const { robotId } = req.body;
if (!robotId) { if (!robotId) {
return res.status(400).json({ message: 'Robot ID is required' }); return res.status(400).json({ message: "Robot ID is required" });
} }
if (!req.user) { if (!req.user) {
return res.status(401).send({ error: 'Unauthorized' }); return res.status(401).send({ error: "Unauthorized" });
} }
try { try {
let robot = await Robot.findOne({ where: { 'recording_meta.id': robotId } }); let robot = await Robot.findOne({
where: { "recording_meta.id": robotId },
});
if (!robot) { if (!robot) {
return res.status(404).json({ message: 'Robot not found' }); return res.status(404).json({ message: "Robot not found" });
} }
await robot.update({ await robot.update({
google_sheet_id: null, google_sheet_id: null,
google_sheet_name: null, google_sheet_name: null,
google_sheet_email: null, google_sheet_email: null,
google_access_token: null, google_access_token: null,
google_refresh_token: null google_refresh_token: null,
}); });
capture( capture("maxun-oss-google-sheet-integration-removed", {
'maxun-oss-google-sheet-integration-removed', user_id: req.user.id,
{ robot_id: robotId,
user_id: req.user.id, deleted_at: new Date().toISOString(),
robot_id: robotId, });
deleted_at: new Date().toISOString()
}
)
res.json({ message: 'Google Sheets integration removed successfully' }); res.json({ message: "Google Sheets integration removed successfully" });
} catch (error: any) { } catch (error: any) {
res.status(500).json({ message: `Error removing Google Sheets integration: ${error.message}` }); res
.status(500)
.json({
message: `Error removing Google Sheets integration: ${error.message}`,
});
} }
}); }
);