Sync File Attachments

/**
 * SuitePortal Universal RESTlet
 *
 * A single RESTlet deployed per tenant that handles all document/file operations
 * for the SuitePortal customer portal.
 *
 * Script ID:     customscript_sp_universal
 * Deployment ID: customdeploy_sp_universal
 *
 * @NApiVersion 2.1
 * @NScriptType Restlet
 * @NModuleScope SameAccount
 */
define(["N/render", "N/record", "N/file", "N/search", "N/encode", "N/runtime", "N/query"], function (
  render,
  record,
  file,
  search,
  encode,
  runtime,
  query,
) {
  function response(action, data, error) {
    if (error) {
      return {
        success: false,
        action: action,
        data: null,
        error: typeof error === "string" ? error : error.message || String(error),
      };
    }
    return { success: true, action: action, data: data, error: null };
  }

  /** action=pdf — Render a transaction record as PDF. */
  function handlePdf(params) {
    var recordType = params.recordType;
    var recordId = params.recordId;
    if (!recordType || !recordId) {
      return response("pdf", null, "recordType and recordId are required");
    }
    var rec = record.load({ type: recordType, id: Number(recordId) });
    var pdfFile = render.transaction({
      entityId: Number(recordId),
      printMode: render.PrintMode.PDF,
    });
    var contents = encode.convert({
      string: pdfFile.getContents(),
      inputEncoding: encode.Encoding.BASE_64,
      outputEncoding: encode.Encoding.BASE_64,
    });
    var tranId = rec.getValue({ fieldId: "tranid" }) || recordId;
    return response("pdf", {
      filename: recordType + "-" + tranId + ".pdf",
      content: contents,
      mimeType: "application/pdf",
    });
  }

  /** action=file — Fetch a single file from the File Cabinet by internal ID. */
  function handleFile(params) {
    var fileId = params.fileId;
    if (!fileId) {
      return response("file", null, "fileId is required");
    }
    var f = file.load({ id: Number(fileId) });
    return response("file", {
      filename: f.name,
      content: encode.convert({
        string: f.getContents(),
        inputEncoding: encode.Encoding.BASE_64,
        outputEncoding: encode.Encoding.BASE_64,
      }),
      mimeType: f.fileType,
      size: f.size,
    });
  }

  /**
   * Find files attached to a transaction by searching the transaction
   * type and joining to "file" (record-level attachments via Communication > Files).
   */
  function getTransactionFiles(recordType, recordId) {
    var rid = Number(recordId);
    var files = [];
    var seen = {};

    var tranSearch = search.create({
      type: recordType,
      filters: [["internalidnumber", "equalto", rid]],
      columns: [
        search.createColumn({ name: "internalid", join: "file" }),
        search.createColumn({ name: "name", join: "file" }),
        search.createColumn({ name: "documentsize", join: "file" }),
        search.createColumn({ name: "filetype", join: "file" }),
        search.createColumn({ name: "created", join: "file" }),
      ],
    });

    tranSearch.run().each(function (result) {
      var fileId = result.getValue({ name: "internalid", join: "file" });
      if (fileId && !seen[fileId]) {
        seen[fileId] = true;
        files.push({
          id: String(fileId),
          name: result.getValue({ name: "name", join: "file" }) || "unknown",
          type: result.getValue({ name: "filetype", join: "file" }) || "",
          size: result.getValue({ name: "documentsize", join: "file" }) || "0",
          created: result.getValue({ name: "created", join: "file" }) || null,
        });
      }
      return true;
    });

    return files;
  }

  /** action=listfiles — List files attached to a single record. */
  function handleListFiles(params) {
    var recordType = params.recordType;
    var recordId = params.recordId;
    if (!recordType || !recordId) {
      return response("listfiles", null, "recordType and recordId are required");
    }
    var files = getTransactionFiles(recordType, recordId);
    return response("listfiles", { files: files });
  }

  /** action=batchlistfiles — List files for multiple records at once (POST only). */
  function handleBatchListFiles(params) {
    var recordType = params.recordType;
    var recordIds = params.recordIds;
    if (!recordType || !recordIds || !recordIds.length) {
      return response("batchlistfiles", null, "recordType and recordIds are required");
    }
    var attachments = {};
    var errors = [];
    for (var i = 0; i < recordIds.length; i++) {
      var rid = Number(recordIds[i]);
      try {
        attachments[String(rid)] = getTransactionFiles(recordType, rid);
      } catch (e) {
        attachments[String(rid)] = [];
        errors.push({ recordId: rid, error: e.message || String(e) });
      }
    }
    return response("batchlistfiles", { attachments: attachments, errors: errors });
  }

  /**
   * Search for messages linked to records by transaction or entity.
   * Returns messages grouped by record ID.
   */
  function getRecordMessages(linkType, recordId) {
    var rid = Number(recordId);
    var messages = [];
    var sql =
      "SELECT m.id, m.subject, m.messagedate, m.authoremail, m.recipientemail, " +
      "m.incoming, m.hasattachment, m.message " +
      "FROM message m " +
      "WHERE m." + linkType + " = ? " +
      "ORDER BY m.messagedate DESC";

    var results = query.runSuiteQL({ query: sql, params: [rid] });
    var rows = results.asMappedResults();

    for (var i = 0; i < rows.length; i++) {
      var row = rows[i];
      messages.push({
        id: String(row.id),
        subject: row.subject || "(No Subject)",
        date: row.messagedate || "",
        authorName: row.authoremail || "",
        recipientName: row.recipientemail || "",
        incoming: row.incoming === "T",
        hasAttachment: row.hasattachment === "T",
        body: row.message || "",
      });
    }

    return messages;
  }

  /** action=batchlistmessages — List messages for multiple records at once (POST only). */
  function handleBatchListMessages(params) {
    var linkType = params.linkType;
    var recordIds = params.recordIds;
    if (!linkType || !recordIds || !recordIds.length) {
      return response("batchlistmessages", null, "linkType and recordIds are required");
    }
    var messages = {};
    var errors = [];
    for (var i = 0; i < recordIds.length; i++) {
      var rid = Number(recordIds[i]);
      try {
        messages[String(rid)] = getRecordMessages(linkType, rid);
      } catch (e) {
        messages[String(rid)] = [];
        errors.push({ recordId: rid, error: e.message || String(e) });
      }
    }
    return response("batchlistmessages", { messages: messages, errors: errors });
  }

  /** action=getmessagebody — Load a single message's full body. */
  function handleGetMessageBody(params) {
    var messageId = params.messageId;
    if (!messageId) {
      return response("getmessagebody", null, "messageId is required");
    }
    var rec = record.load({ type: "message", id: Number(messageId) });
    return response("getmessagebody", {
      messageId: String(messageId),
      subject: rec.getValue({ fieldId: "subject" }) || "",
      body: rec.getValue({ fieldId: "message" }) || "",
    });
  }

  /** action=ping — Health check / connection test. */
  function handlePing() {
    return response("ping", {
      status: "ok",
      timestamp: new Date().toISOString(),
      account: runtime.accountId,
    });
  }

  function get(context) {
    var action = context.action || "ping";
    try {
      switch (action) {
        case "pdf": return handlePdf(context);
        case "file": return handleFile(context);
        case "listfiles": return handleListFiles(context);
        case "batchlistfiles": return handleBatchListFiles(context);
        case "batchlistmessages": return handleBatchListMessages(context);
        case "getmessagebody": return handleGetMessageBody(context);
        case "ping": return handlePing();
        default: return response(action, null, "Unknown action: " + action);
      }
    } catch (e) {
      log.error({ title: "SP Universal RESTlet Error", details: e.message || e });
      return response(action, null, e.message || String(e));
    }
  }

  function post(context) {
    var action = context.action || "ping";
    try {
      switch (action) {
        case "pdf": return handlePdf(context);
        case "file": return handleFile(context);
        case "listfiles": return handleListFiles(context);
        case "batchlistfiles": return handleBatchListFiles(context);
        case "batchlistmessages": return handleBatchListMessages(context);
        case "getmessagebody": return handleGetMessageBody(context);
        case "ping": return handlePing();
        default: return response(action, null, "Unknown action: " + action);
      }
    } catch (e) {
      log.error({ title: "SP Universal RESTlet Error", details: e.message || e });
      return response(action, null, e.message || String(e));
    }
  }

  return { get: get, post: post };
});

app/common/scripting/scriptrecord.nl?id=1234  →  Script ID: 1234
app/common/scripting/scriptdeployment.nl?script=1234&deploy=1  →  Deploy ID: 1

Attachment fetch complete: totalRecords=142, recordsWithAttachments=23