Spaces:
Paused
Paused
| const prisma = require('../lib/prisma'); | |
| const wsManager = require('../lib/ws'); | |
| // Helper: get user's workspace | |
| async function getUserWorkspace(userId) { | |
| const member = await prisma.teamMember.findFirst({ | |
| where: { userId }, | |
| include: { workspace: true }, | |
| }); | |
| return member; | |
| } | |
| const createThread = async (req, res) => { | |
| const { receiverWorkspaceId } = req.body; | |
| if (!receiverWorkspaceId) { | |
| return res.status(400).json({ error: 'Receiver workspace ID required' }); | |
| } | |
| try { | |
| const member = await getUserWorkspace(req.user.userId); | |
| if (!member) return res.status(404).json({ error: 'You have no workspace' }); | |
| if (member.workspaceId === receiverWorkspaceId) { | |
| return res.status(400).json({ error: 'Cannot send request to your own workspace' }); | |
| } | |
| // Check for existing thread | |
| const existing = await prisma.exchangeThread.findFirst({ | |
| where: { | |
| OR: [ | |
| { giverWorkspaceId: member.workspaceId, receiverWorkspaceId }, | |
| { giverWorkspaceId: receiverWorkspaceId, receiverWorkspaceId: member.workspaceId }, | |
| ], | |
| }, | |
| }); | |
| if (existing) return res.status(409).json({ error: 'Thread already exists between these workspaces' }); | |
| const thread = await prisma.exchangeThread.create({ | |
| data: { | |
| giverWorkspaceId: member.workspaceId, | |
| receiverWorkspaceId, | |
| stage: 'NEW', | |
| status: 'PENDING', | |
| giverAccepted: true, | |
| }, | |
| include: { | |
| giverWorkspace: true, | |
| receiverWorkspace: true, | |
| }, | |
| }); | |
| wsManager.sendNotification(receiverWorkspaceId, { | |
| type: 'new_connection', | |
| threadId: thread.id, | |
| senderWorkspaceName: thread.giverWorkspace.websiteName, | |
| senderWorkspaceDomain: thread.giverWorkspace.domain, | |
| }); | |
| res.status(201).json({ thread }); | |
| } catch (err) { | |
| console.error(err); | |
| res.status(500).json({ error: 'Server error' }); | |
| } | |
| }; | |
| const getThreads = async (req, res) => { | |
| const { filter } = req.query; // all | new | in | out | |
| try { | |
| const member = await getUserWorkspace(req.user.userId); | |
| if (!member) return res.status(404).json({ error: 'No workspace found' }); | |
| const wsId = member.workspaceId; | |
| let where = { | |
| OR: [{ giverWorkspaceId: wsId }, { receiverWorkspaceId: wsId }], | |
| status: { not: 'REJECTED' }, | |
| }; | |
| if (filter === 'new') where.stage = 'NEW'; | |
| else if (filter === 'in') { | |
| where = { receiverWorkspaceId: wsId, status: { not: 'REJECTED' } }; | |
| } | |
| else if (filter === 'out') { | |
| where = { giverWorkspaceId: wsId, status: { not: 'REJECTED' } }; | |
| } | |
| else if (filter === 'rejected') { | |
| where = { rejectedByWorkspaceId: wsId, status: 'REJECTED' }; | |
| } | |
| const threads = await prisma.exchangeThread.findMany({ | |
| where, | |
| include: { | |
| giverWorkspace: { | |
| select: { | |
| id: true, domain: true, websiteName: true, niche: true, country: true, description: true, createdAt: true, | |
| teamMembers: { where: { role: 'OWNER' }, select: { user: { select: { name: true } } } } | |
| } | |
| }, | |
| receiverWorkspace: { | |
| select: { | |
| id: true, domain: true, websiteName: true, niche: true, country: true, description: true, createdAt: true, | |
| teamMembers: { where: { role: 'OWNER' }, select: { user: { select: { name: true } } } } | |
| } | |
| }, | |
| messages: { orderBy: { timestamp: 'desc' }, take: 1 }, | |
| linkPlacement: true, | |
| }, | |
| orderBy: { updatedAt: 'desc' }, | |
| }); | |
| let settings = await prisma.systemSettings.findUnique({ where: { id: 'singleton' } }); | |
| const rejectLimit = settings ? settings.rejectLimit : 5; | |
| res.json({ threads, workspaceId: wsId, rejectLimit }); | |
| } catch (err) { | |
| console.error(err); | |
| res.status(500).json({ error: 'Server error' }); | |
| } | |
| }; | |
| const getThreadById = async (req, res) => { | |
| try { | |
| const member = await getUserWorkspace(req.user.userId); | |
| if (!member) return res.status(404).json({ error: 'No workspace found' }); | |
| const thread = await prisma.exchangeThread.findUnique({ | |
| where: { id: req.params.id }, | |
| include: { | |
| giverWorkspace: { | |
| include: { teamMembers: { where: { role: 'OWNER' }, select: { user: { select: { name: true } } } } } | |
| }, | |
| receiverWorkspace: { | |
| include: { teamMembers: { where: { role: 'OWNER' }, select: { user: { select: { name: true } } } } } | |
| }, | |
| messages: { | |
| orderBy: { timestamp: 'asc' }, | |
| include: { sender: { select: { id: true, name: true, email: true } } }, | |
| }, | |
| linkPlacement: true, | |
| }, | |
| }); | |
| if (!thread) return res.status(404).json({ error: 'Thread not found' }); | |
| // Verify access | |
| if (thread.giverWorkspaceId !== member.workspaceId && thread.receiverWorkspaceId !== member.workspaceId) { | |
| return res.status(403).json({ error: 'Access denied' }); | |
| } | |
| res.json({ thread, workspaceId: member.workspaceId }); | |
| } catch (err) { | |
| console.error(err); | |
| res.status(500).json({ error: 'Server error' }); | |
| } | |
| }; | |
| const updateThreadStatus = async (req, res) => { | |
| const { status } = req.body; // ACCEPTED | REJECTED | |
| if (!['ACCEPTED', 'REJECTED'].includes(status)) { | |
| return res.status(400).json({ error: 'Status must be ACCEPTED or REJECTED' }); | |
| } | |
| try { | |
| const member = await getUserWorkspace(req.user.userId); | |
| if (!member) return res.status(404).json({ error: 'No workspace found' }); | |
| const thread = await prisma.exchangeThread.findUnique({ where: { id: req.params.id } }); | |
| if (!thread) return res.status(404).json({ error: 'Thread not found' }); | |
| const isGiver = thread.giverWorkspaceId === member.workspaceId; | |
| const isReceiver = thread.receiverWorkspaceId === member.workspaceId; | |
| if (!isGiver && !isReceiver) { | |
| return res.status(403).json({ error: 'Access denied' }); | |
| } | |
| let updateData = {}; | |
| let newStatus = thread.status; | |
| let newStage = thread.stage; | |
| let giverAccepted = thread.giverAccepted; | |
| let receiverAccepted = thread.receiverAccepted; | |
| if (status === 'REJECTED') { | |
| let settings = await prisma.systemSettings.findUnique({ where: { id: 'singleton' } }); | |
| const rejectLimit = settings ? settings.rejectLimit : 5; | |
| const rejectedCount = await prisma.exchangeThread.count({ | |
| where: { rejectedByWorkspaceId: member.workspaceId, status: 'REJECTED' } | |
| }); | |
| if (rejectedCount >= rejectLimit) { | |
| return res.status(403).json({ error: `Cannot reject more than ${rejectLimit} requests` }); | |
| } | |
| newStatus = 'REJECTED'; | |
| newStage = 'NEW'; | |
| updateData = { status: newStatus, stage: newStage, rejectedByWorkspaceId: member.workspaceId }; | |
| } else if (status === 'ACCEPTED') { | |
| if (isGiver) giverAccepted = true; | |
| if (isReceiver) receiverAccepted = true; | |
| updateData = { giverAccepted, receiverAccepted }; | |
| if (giverAccepted && receiverAccepted) { | |
| newStatus = 'ACCEPTED'; | |
| newStage = 'CHAT'; | |
| updateData.status = newStatus; | |
| updateData.stage = newStage; | |
| } | |
| } | |
| const updated = await prisma.exchangeThread.update({ | |
| where: { id: req.params.id }, | |
| data: updateData, | |
| include: { | |
| giverWorkspace: true, | |
| receiverWorkspace: true, | |
| }, | |
| }); | |
| // Determine who to notify | |
| const otherId = isGiver ? thread.receiverWorkspaceId : thread.giverWorkspaceId; | |
| const selfWorkspace = isGiver ? updated.giverWorkspace : updated.receiverWorkspace; | |
| if (newStatus === 'ACCEPTED' && newStage === 'CHAT') { | |
| wsManager.sendNotification(otherId, { | |
| type: 'connection_accepted', | |
| threadId: updated.id, | |
| receiverWorkspaceName: selfWorkspace.websiteName, | |
| receiverWorkspaceDomain: selfWorkspace.domain, | |
| }); | |
| } else if (newStatus === 'REJECTED') { | |
| wsManager.sendNotification(otherId, { | |
| type: 'connection_rejected', | |
| threadId: updated.id, | |
| receiverWorkspaceName: selfWorkspace.websiteName, | |
| receiverWorkspaceDomain: selfWorkspace.domain, | |
| }); | |
| } | |
| res.json({ thread: updated }); | |
| } catch (err) { | |
| console.error(err); | |
| res.status(500).json({ error: 'Server error' }); | |
| } | |
| }; | |
| module.exports = { | |
| createThread, | |
| getThreads, | |
| getThreadById, | |
| updateThreadStatus, | |
| }; | |