Converse converse.js

API Documentation

Source: headless/plugins/muc/parsers.js

  1. import dayjs from 'dayjs';
  2. import {
  3.     StanzaParseError,
  4.     getChatMarker,
  5.     getChatState,
  6.     getCorrectionAttributes,
  7.     getEncryptionAttributes,
  8.     getErrorAttributes,
  9.     getMediaURLsMetadata,
  10.     getOpenGraphMetadata,
  11.     getOutOfBandAttributes,
  12.     getReceiptId,
  13.     getReferences,
  14.     getRetractionAttributes,
  15.     getSpoilerAttributes,
  16.     getStanzaIDs,
  17.     isArchived,
  18.     isCarbon,
  19.     isHeadline,
  20.     isValidReceiptRequest,
  21.     throwErrorIfInvalidForward,
  22. } from '@converse/headless/shared/parsers';
  23. import { _converse, api, converse } from '@converse/headless/core';
  25. const { Strophe, sizzle, u } = converse.env;
  26. const { NS } = Strophe;
  28. /**
  29.  * Parses a message stanza for XEP-0317 MEP notification data
  30.  * @param { Element } stanza - The message stanza
  31.  * @returns { Array } Returns an array of objects representing <activity> elements.
  32.  */
  33. export function getMEPActivities (stanza) {
  34.     const items_el = sizzle(`items[node="${Strophe.NS.CONFINFO}"]`, stanza).pop();
  35.     if (!items_el) {
  36.         return null;
  37.     }
  38.     const from = stanza.getAttribute('from');
  39.     const msgid = stanza.getAttribute('id');
  40.     const selector = `item `+
  41.         `conference-info[xmlns="${Strophe.NS.CONFINFO}"] `+
  42.         `activity[xmlns="${Strophe.NS.ACTIVITY}"]`;
  43.     return sizzle(selector, items_el).map(el => {
  44.         const message = el.querySelector('text')?.textContent;
  45.         if (message) {
  46.             const references = getReferences(stanza);
  47.             const reason = el.querySelector('reason')?.textContent;
  48.             return { from, msgid, message, reason,  references, 'type': 'mep' };
  49.         }
  50.         return {};
  51.     });
  52. }
  54. /**
  55.  * Given a MUC stanza, check whether it has extended message information that
  56.  * includes the sender's real JID, as described here:
  57.  * https://xmpp.org/extensions/xep-0313.html#business-storeret-muc-archives
  58.  *
  59.  * If so, parse and return that data and return the user's JID
  60.  *
  61.  * Note, this function doesn't check whether this is actually a MAM archived stanza.
  62.  *
  63.  * @private
  64.  * @param { Element } stanza - The message stanza
  65.  * @returns { Object }
  66.  */
  67. function getJIDFromMUCUserData (stanza) {
  68.     const item = sizzle(`x[xmlns="${Strophe.NS.MUC_USER}"] item`, stanza).pop();
  69.     return item?.getAttribute('jid');
  70. }
  72. /**
  73.  * @private
  74.  * @param { Element } stanza - The message stanza
  75.  * @param { Element } original_stanza - The original stanza, that contains the
  76.  *  message stanza, if it was contained, otherwise it's the message stanza itself.
  77.  * @returns { Object }
  78.  */
  79. function getModerationAttributes (stanza) {
  80.     const fastening = sizzle(`apply-to[xmlns="${Strophe.NS.FASTEN}"]`, stanza).pop();
  81.     if (fastening) {
  82.         const applies_to_id = fastening.getAttribute('id');
  83.         const moderated = sizzle(`moderated[xmlns="${Strophe.NS.MODERATE}"]`, fastening).pop();
  84.         if (moderated) {
  85.             const retracted = sizzle(`retract[xmlns="${Strophe.NS.RETRACT}"]`, moderated).pop();
  86.             if (retracted) {
  87.                 return {
  88.                     'editable': false,
  89.                     'moderated': 'retracted',
  90.                     'moderated_by': moderated.getAttribute('by'),
  91.                     'moderated_id': applies_to_id,
  92.                     'moderation_reason': moderated.querySelector('reason')?.textContent
  93.                 };
  94.             }
  95.         }
  96.     } else {
  97.         const tombstone = sizzle(`> moderated[xmlns="${Strophe.NS.MODERATE}"]`, stanza).pop();
  98.         if (tombstone) {
  99.             const retracted = sizzle(`retracted[xmlns="${Strophe.NS.RETRACT}"]`, tombstone).pop();
  100.             if (retracted) {
  101.                 return {
  102.                     'editable': false,
  103.                     'is_tombstone': true,
  104.                     'moderated_by': tombstone.getAttribute('by'),
  105.                     'retracted': tombstone.getAttribute('stamp'),
  106.                     'moderation_reason': tombstone.querySelector('reason')?.textContent
  107.                 };
  108.             }
  109.         }
  110.     }
  111.     return {};
  112. }
  114. function getOccupantID (stanza, chatbox) {
  115.     if (chatbox.features.get(Strophe.NS.OCCUPANTID)) {
  116.         return sizzle(`occupant-id[xmlns="${Strophe.NS.OCCUPANTID}"]`, stanza).pop()?.getAttribute('id');
  117.     }
  118. }
  120. /**
  121.  * Determines whether the sender of this MUC message is the current user or
  122.  * someone else.
  123.  * @param { MUCMessageAttributes } attrs
  124.  * @param { _converse.ChatRoom } chatbox
  125.  * @returns { 'me'|'them' }
  126.  */
  127. function getSender (attrs, chatbox) {
  128.     let is_me;
  129.     const own_occupant_id = chatbox.get('occupant_id');
  131.     if (own_occupant_id) {
  132.         is_me = attrs.occupant_id === own_occupant_id;
  133.     } else if (attrs.from_real_jid) {
  134.         is_me = Strophe.getBareJidFromJid(attrs.from_real_jid) === _converse.bare_jid;
  135.     } else {
  136.         is_me = attrs.nick === chatbox.get('nick')
  137.     }
  138.     return is_me ? 'me' : 'them';
  139. }
  141. /**
  142.  * Parses a passed in message stanza and returns an object of attributes.
  143.  * @param { Element } stanza - The message stanza
  144.  * @param { Element } original_stanza - The original stanza, that contains the
  145.  *  message stanza, if it was contained, otherwise it's the message stanza itself.
  146.  * @param { _converse.ChatRoom } chatbox
  147.  * @param { _converse } _converse
  148.  * @returns { Promise<MUCMessageAttributes|Error> }
  149.  */
  150. export async function parseMUCMessage (stanza, chatbox) {
  151.     throwErrorIfInvalidForward(stanza);
  153.     const selector = `[xmlns="${NS.MAM}"] > forwarded[xmlns="${NS.FORWARD}"] > message`;
  154.     const original_stanza = stanza;
  155.     stanza = sizzle(selector, stanza).pop() || stanza;
  157.     if (sizzle(`message > forwarded[xmlns="${Strophe.NS.FORWARD}"]`, stanza).length) {
  158.         return new StanzaParseError(
  159.             `Invalid Stanza: Forged MAM groupchat message from ${stanza.getAttribute('from')}`,
  160.             stanza
  161.         );
  162.     }
  163.     const delay = sizzle(`delay[xmlns="${Strophe.NS.DELAY}"]`, original_stanza).pop();
  164.     const from = stanza.getAttribute('from');
  165.     const marker = getChatMarker(stanza);
  167.     /**
  168.      * @typedef { Object } MUCMessageAttributes
  169.      * The object which {@link parseMUCMessage} returns
  170.      * @property { ('me'|'them') } sender - Whether the message was sent by the current user or someone else
  171.      * @property { Array<Object> } activities - A list of objects representing XEP-0316 MEP notification data
  172.      * @property { Array<Object> } references - A list of objects representing XEP-0372 references
  173.      * @property { Boolean } editable - Is this message editable via XEP-0308?
  174.      * @property { Boolean } is_archived -  Is this message from a XEP-0313 MAM archive?
  175.      * @property { Boolean } is_carbon - Is this message a XEP-0280 Carbon?
  176.      * @property { Boolean } is_delayed - Was delivery of this message was delayed as per XEP-0203?
  177.      * @property { Boolean } is_encrypted -  Is this message XEP-0384  encrypted?
  178.      * @property { Boolean } is_error - Whether an error was received for this message
  179.      * @property { Boolean } is_headline - Is this a "headline" message?
  180.      * @property { Boolean } is_markable - Can this message be marked with a XEP-0333 chat marker?
  181.      * @property { Boolean } is_marker - Is this message a XEP-0333 Chat Marker?
  182.      * @property { Boolean } is_only_emojis - Does the message body contain only emojis?
  183.      * @property { Boolean } is_spoiler - Is this a XEP-0382 spoiler message?
  184.      * @property { Boolean } is_tombstone - Is this a XEP-0424 tombstone?
  185.      * @property { Boolean } is_unstyled - Whether XEP-0393 styling hints should be ignored
  186.      * @property { Boolean } is_valid_receipt_request - Does this message request a XEP-0184 receipt (and is not from us or a carbon or archived message)
  187.      * @property { Object } encrypted -  XEP-0384 encryption payload attributes
  188.      * @property { String } body - The contents of the <body> tag of the message stanza
  189.      * @property { String } chat_state - The XEP-0085 chat state notification contained in this message
  190.      * @property { String } edited - An ISO8601 string recording the time that the message was edited per XEP-0308
  191.      * @property { String } error_condition - The defined error condition
  192.      * @property { String } error_text - The error text received from the server
  193.      * @property { String } error_type - The type of error received from the server
  194.      * @property { String } from - The sender JID (${muc_jid}/${nick})
  195.      * @property { String } from_muc - The JID of the MUC from which this message was sent
  196.      * @property { String } from_real_jid - The real JID of the sender, if available
  197.      * @property { String } fullname - The full name of the sender
  198.      * @property { String } marker - The XEP-0333 Chat Marker value
  199.      * @property { String } marker_id - The `id` attribute of a XEP-0333 chat marker
  200.      * @property { String } moderated - The type of XEP-0425 moderation (if any) that was applied
  201.      * @property { String } moderated_by - The JID of the user that moderated this message
  202.      * @property { String } moderated_id - The  XEP-0359 Stanza ID of the message that this one moderates
  203.      * @property { String } moderation_reason - The reason provided why this message moderates another
  204.      * @property { String } msgid - The root `id` attribute of the stanza
  205.      * @property { String } nick - The MUC nickname of the sender
  206.      * @property { String } occupant_id - The XEP-0421 occupant ID
  207.      * @property { String } oob_desc - The description of the XEP-0066 out of band data
  208.      * @property { String } oob_url - The URL of the XEP-0066 out of band data
  209.      * @property { String } origin_id - The XEP-0359 Origin ID
  210.      * @property { String } receipt_id - The `id` attribute of a XEP-0184 <receipt> element
  211.      * @property { String } received - An ISO8601 string recording the time that the message was received
  212.      * @property { String } replace_id - The `id` attribute of a XEP-0308 <replace> element
  213.      * @property { String } retracted - An ISO8601 string recording the time that the message was retracted
  214.      * @property { String } retracted_id - The `id` attribute of a XEP-424 <retracted> element
  215.      * @property { String } spoiler_hint  The XEP-0382 spoiler hint
  216.      * @property { String } stanza_id - The XEP-0359 Stanza ID. Note: the key is actualy `stanza_id ${by_jid}` and there can be multiple.
  217.      * @property { String } subject - The <subject> element value
  218.      * @property { String } thread - The <thread> element value
  219.      * @property { String } time - The time (in ISO8601 format), either given by the XEP-0203 <delay> element, or of receipt.
  220.      * @property { String } to - The recipient JID
  221.      * @property { String } type - The type of message
  222.      */
  223.     let attrs = Object.assign(
  224.         {
  225.             from,
  226.             'activities': getMEPActivities(stanza),
  227.             'body': stanza.querySelector(':scope > body')?.textContent?.trim(),
  228.             'chat_state': getChatState(stanza),
  229.             'from_muc': Strophe.getBareJidFromJid(from),
  230.             'is_archived': isArchived(original_stanza),
  231.             'is_carbon': isCarbon(original_stanza),
  232.             'is_delayed': !!delay,
  233.             'is_forwarded': !!stanza.querySelector('forwarded'),
  234.             'is_headline': isHeadline(stanza),
  235.             'is_markable': !!sizzle(`markable[xmlns="${Strophe.NS.MARKERS}"]`, stanza).length,
  236.             'is_marker': !!marker,
  237.             'is_unstyled': !!sizzle(`unstyled[xmlns="${Strophe.NS.STYLING}"]`, stanza).length,
  238.             'marker_id': marker && marker.getAttribute('id'),
  239.             'msgid': stanza.getAttribute('id') || original_stanza.getAttribute('id'),
  240.             'nick': Strophe.unescapeNode(Strophe.getResourceFromJid(from)),
  241.             'occupant_id': getOccupantID(stanza, chatbox),
  242.             'receipt_id': getReceiptId(stanza),
  243.             'received': new Date().toISOString(),
  244.             'references': getReferences(stanza),
  245.             'subject': stanza.querySelector('subject')?.textContent,
  246.             'thread': stanza.querySelector('thread')?.textContent,
  247.             'time': delay ? dayjs(delay.getAttribute('stamp')).toISOString() : new Date().toISOString(),
  248.             'to': stanza.getAttribute('to'),
  249.             'type': stanza.getAttribute('type')
  250.         },
  251.         getErrorAttributes(stanza),
  252.         getOutOfBandAttributes(stanza),
  253.         getSpoilerAttributes(stanza),
  254.         getCorrectionAttributes(stanza, original_stanza),
  255.         getStanzaIDs(stanza, original_stanza),
  256.         getOpenGraphMetadata(stanza),
  257.         getRetractionAttributes(stanza, original_stanza),
  258.         getModerationAttributes(stanza),
  259.         getEncryptionAttributes(stanza, _converse),
  260.     );
  262.     await api.emojis.initialize();
  264.     attrs.from_real_jid = attrs.is_archived && getJIDFromMUCUserData(stanza) ||
  265.         chatbox.occupants.findOccupant(attrs)?.get('jid');
  267.     attrs = Object.assign( {
  268.         'is_only_emojis': attrs.body ? u.isOnlyEmojis(attrs.body) : false,
  269.         'is_valid_receipt_request': isValidReceiptRequest(stanza, attrs),
  270.         'message': attrs.body || attrs.error, // TODO: Should only be used for error and info messages
  271.         'sender': getSender(attrs, chatbox),
  272.     }, attrs);
  274.     if (attrs.is_archived && original_stanza.getAttribute('from') !== attrs.from_muc) {
  275.         return new StanzaParseError(
  276.             `Invalid Stanza: Forged MAM message from ${original_stanza.getAttribute('from')}`,
  277.             stanza
  278.         );
  279.     } else if (attrs.is_archived && original_stanza.getAttribute('from') !== chatbox.get('jid')) {
  280.         return new StanzaParseError(
  281.             `Invalid Stanza: Forged MAM groupchat message from ${stanza.getAttribute('from')}`,
  282.             stanza
  283.         );
  284.     } else if (attrs.is_carbon) {
  285.         return new StanzaParseError('Invalid Stanza: MUC messages SHOULD NOT be XEP-0280 carbon copied', stanza);
  286.     }
  287.     // We prefer to use one of the XEP-0359 unique and stable stanza IDs as the Model id, to avoid duplicates.
  288.     attrs['id'] = attrs['origin_id'] || attrs[`stanza_id ${attrs.from_muc || attrs.from}`] || u.getUniqueId();
  290.     /**
  291.      * *Hook* which allows plugins to add additional parsing
  292.      * @event _converse#parseMUCMessage
  293.      */
  294.     attrs = await api.hook('parseMUCMessage', stanza, attrs);
  296.     // We call this after the hook, to allow plugins to decrypt encrypted
  297.     // messages, since we need to parse the message text to determine whether
  298.     // there are media urls.
  299.     return Object.assign(attrs, getMediaURLsMetadata(attrs.is_encrypted ? attrs.plaintext : attrs.body));
  300. }
  302. /**
  303.  * Given an IQ stanza with a member list, create an array of objects containing
  304.  * known member data (e.g. jid, nick, role, affiliation).
  305.  * @private
  306.  * @method muc_utils#parseMemberListIQ
  307.  * @returns { MemberListItem[] }
  308.  */
  309. export function parseMemberListIQ (iq) {
  310.     return sizzle(`query[xmlns="${Strophe.NS.MUC_ADMIN}"] item`, iq).map(item => {
  311.         /**
  312.          * @typedef {Object} MemberListItem
  313.          * Either the JID or the nickname (or both) will be available.
  314.          * @property {string} affiliation
  315.          * @property {string} [role]
  316.          * @property {string} [jid]
  317.          * @property {string} [nick]
  318.          */
  319.         const data = {
  320.             'affiliation': item.getAttribute('affiliation')
  321.         };
  322.         const jid = item.getAttribute('jid');
  323.         if (u.isValidJID(jid)) {
  324.             data['jid'] = jid;
  325.         } else {
  326.             // XXX: Prosody sends nick for the jid attribute value
  327.             // Perhaps for anonymous room?
  328.             data['nick'] = jid;
  329.         }
  330.         const nick = item.getAttribute('nick');
  331.         if (nick) {
  332.             data['nick'] = nick;
  333.         }
  334.         const role = item.getAttribute('role');
  335.         if (role) {
  336.             data['role'] = nick;
  337.         }
  338.         return data;
  339.     });
  340. }
  342. /**
  343.  * Parses a passed in MUC presence stanza and returns an object of attributes.
  344.  * @method parseMUCPresence
  345.  * @param { Element } stanza - The presence stanza
  346.  * @param { _converse.ChatRoom } chatbox
  347.  * @returns { MUCPresenceAttributes }
  348.  */
  349. export function parseMUCPresence (stanza, chatbox) {
  350.     /**
  351.      * @typedef { Object } MUCPresenceAttributes
  352.      * The object which {@link parseMUCPresence} returns
  353.      * @property { ("offline|online") } show
  354.      * @property { Array<MUCHat> } hats - An array of XEP-0317 hats
  355.      * @property { Array<string> } states
  356.      * @property { String } from - The sender JID (${muc_jid}/${nick})
  357.      * @property { String } nick - The nickname of the sender
  358.      * @property { String } occupant_id - The XEP-0421 occupant ID
  359.      * @property { String } type - The type of presence
  360.      */
  361.     const from = stanza.getAttribute('from');
  362.     const type = stanza.getAttribute('type');
  363.     const data = {
  364.         'is_me': !!stanza.querySelector("status[code='110']"),
  365.         'from': from,
  366.         'occupant_id': getOccupantID(stanza, chatbox),
  367.         'nick': Strophe.getResourceFromJid(from),
  368.         'type': type,
  369.         'states': [],
  370.         'hats': [],
  371.         'show': type !== 'unavailable' ? 'online' : 'offline'
  372.     };
  374.     Array.from(stanza.children).forEach(child => {
  375.         if (child.matches('status')) {
  376.             data.status = child.textContent || null;
  377.         } else if (child.matches('show')) {
  378.             data.show = child.textContent || 'online';
  379.         } else if (child.matches('x') && child.getAttribute('xmlns') === Strophe.NS.MUC_USER) {
  380.             Array.from(child.children).forEach(item => {
  381.                 if (item.nodeName === 'item') {
  382.                     data.affiliation = item.getAttribute('affiliation');
  383.                     data.role = item.getAttribute('role');
  384.                     data.jid = item.getAttribute('jid');
  385.                     data.nick = item.getAttribute('nick') || data.nick;
  386.                 } else if (item.nodeName == 'status' && item.getAttribute('code')) {
  387.                     data.states.push(item.getAttribute('code'));
  388.                 }
  389.             });
  390.         } else if (child.matches('x') && child.getAttribute('xmlns') === Strophe.NS.VCARDUPDATE) {
  391.             data.image_hash = child.querySelector('photo')?.textContent;
  392.         } else if (child.matches('hats') && child.getAttribute('xmlns') === Strophe.NS.MUC_HATS) {
  393.             /**
  394.              * @typedef { Object } MUCHat
  395.              * Object representing a XEP-0371 Hat
  396.              * @property { String } title
  397.              * @property { String } uri
  398.              */
  399.             data['hats'] = Array.from(child.children).map(
  400.                 c =>
  401.                     c.matches('hat') && {
  402.                         'title': c.getAttribute('title'),
  403.                         'uri': c.getAttribute('uri')
  404.                     }
  405.             );
  406.         }
  407.     });
  408.     return data;
  409. }