bodyshop/server/sms/receive.js

const path = require("path");
require("dotenv").config({
  path: path.resolve(process.cwd(), `.env.${process.env.NODE_ENV || "development"}`)
});

const client = require("../graphql-client/graphql-client").client;
const queries = require("../graphql-client/queries");
const { phone } = require("phone");
const { admin } = require("../firebase/firebase-handler");
const logger = require("../utils/logger");
const InstanceManager = require("../utils/instanceMgr").default;

exports.receive = async (req, res) => {
  const {
    ioRedis,
    ioHelpers: { getBodyshopRoom, getBodyshopConversationRoom }
  } = req;

  const loggerData = {
    msid: req.body.SmsMessageSid,
    text: req.body.Body,
    image: !!req.body.MediaUrl0,
    image_path: generateMediaArray(req.body)
  };

  logger.log("sms-inbound", "DEBUG", "api", null, loggerData);

  if (!req.body || !req.body.MessagingServiceSid || !req.body.SmsMessageSid) {
    logger.log("sms-inbound-error", "ERROR", "api", null, {
      ...loggerData,
      type: "malformed-request"
    });
    return res.status(400).json({ success: false, error: "Malformed Request" });
  }

  try {
    // Step 1: Find the bodyshop and existing conversation
    const response = await client.request(queries.FIND_BODYSHOP_BY_MESSAGING_SERVICE_SID, {
      mssid: req.body.MessagingServiceSid,
      phone: phone(req.body.From).phoneNumber
    });

    if (!response.bodyshops[0]) {
      return res.status(400).json({ success: false, error: "No matching bodyshop" });
    }

    const bodyshop = response.bodyshops[0];

    // Sort conversations by `updated_at` (or `created_at`) and pick the last one
    const sortedConversations = bodyshop.conversations.sort((a, b) => new Date(a.created_at) - new Date(b.created_at));
    const existingConversation = sortedConversations.length
      ? sortedConversations[sortedConversations.length - 1]
      : null;

    let conversationid;
    let newMessage = {
      msid: req.body.SmsMessageSid,
      text: req.body.Body,
      image: !!req.body.MediaUrl0,
      image_path: generateMediaArray(req.body),
      isoutbound: false,
      userid: null // Add additional fields as necessary
    };

    if (existingConversation) {
      // Use the existing conversation
      conversationid = existingConversation.id;

      // Unarchive the conversation if necessary
      if (existingConversation.archived) {
        await client.request(queries.UNARCHIVE_CONVERSATION, {
          id: conversationid,
          archived: false
        });
      }
    } else {
      // Create a new conversation
      const newConversationResponse = await client.request(queries.CREATE_CONVERSATION, {
        conversation: {
          bodyshopid: bodyshop.id,
          phone_num: phone(req.body.From).phoneNumber,
          archived: false
        }
      });
      const createdConversation = newConversationResponse.insert_conversations.returning[0];
      conversationid = createdConversation.id;
    }

    // Ensure `conversationid` is added to the message
    newMessage.conversationid = conversationid;

    // Step 3: Insert the message into the conversation
    const insertresp = await client.request(queries.INSERT_MESSAGE, {
      msg: newMessage,
      conversationid: conversationid
    });

    const message = insertresp?.insert_messages?.returning?.[0];
    const conversation = message?.conversation || null;

    if (!conversation) {
      throw new Error("Conversation data is missing from the response.");
    }

    // Step 4: Notify clients through Redis
    const broadcastRoom = getBodyshopRoom(conversation.bodyshop.id);
    const conversationRoom = getBodyshopConversationRoom({
      bodyshopId: conversation.bodyshop.id,
      conversationId: conversation.id
    });

    const commonPayload = {
      isoutbound: false,
      conversationId: conversation.id,
      updated_at: message.updated_at,
      msid: message.sid
    };

    ioRedis.to(broadcastRoom).emit("new-message-summary", {
      ...commonPayload,
      existingConversation: !!existingConversation,
      newConversation: !existingConversation ? conversation : null,
      summary: true
    });

    ioRedis.to(conversationRoom).emit("new-message-detailed", {
      newMessage: message,
      ...commonPayload,
      newConversation: !existingConversation ? conversation : null,
      existingConversation: !!existingConversation,
      summary: false
    });

    // Step 5: Send FCM notification
    const fcmresp = await admin.messaging().send({
      topic: `${message.conversation.bodyshop.imexshopid}-messaging`,
      notification: {
        title: InstanceManager({
          imex: `ImEX Online Message - ${message.conversation.phone_num}`,
          rome: `Rome Online Message - ${message.conversation.phone_num}`,
          promanager: `ProManager Message - ${message.conversation.phone_num}`
        }),
        body: message.image_path ? `Image ${message.text}` : message.text
      },
      data: {
        type: "messaging-inbound",
        conversationid: message.conversationid || "",
        text: message.text || "",
        messageid: message.id || "",
        phone_num: message.conversation.phone_num || ""
      }
    });

    logger.log("sms-inbound-success", "DEBUG", "api", null, {
      newMessage,
      fcmresp
    });

    res.status(200).send("");
  } catch (e) {
    handleError(req, e, res, "RECEIVE_MESSAGE");
  }
};

const generateMediaArray = (body) => {
  const { NumMedia } = body;
  if (parseInt(NumMedia) > 0) {
    const ret = [];
    for (let i = 0; i < parseInt(NumMedia); i++) {
      ret.push(body[`MediaUrl${i}`]);
    }
    return ret;
  } else {
    return null;
  }
};

const handleError = (req, error, res, context) => {
  logger.log("sms-inbound-error", "ERROR", "api", null, {
    msid: req.body.SmsMessageSid,
    text: req.body.Body,
    image: !!req.body.MediaUrl0,
    image_path: generateMediaArray(req.body),
    messagingServiceSid: req.body.MessagingServiceSid,
    context,
    error
  });

  res.status(500).json({ error: error.message || "Internal Server Error" });
};