@webex/plugin-meetings 3.1.0 → 3.3.0

package/src/meeting/voicea-meeting.ts

@@ -1,3 +1,5 @@
+import {type MeetingTranscriptPayload} from '@webex/internal-plugin-voicea';
+
 export const getSpeaker = (members, csis = []) =>
   Object.values(members).find((member: any) => {
     const memberCSIs = member.participant.status.csis ?? [];
@@ -31,43 +33,16 @@ export const getSpeakerFromProxyOrStore = ({csisKey, meetingMembers, transcriptD
   return {speaker, needsCaching};
 };
 
-export const processNewCaptions = ({data, meeting}) => {
+export const processNewCaptions = ({
+  data,
+  meeting,
+}: {
+  data: MeetingTranscriptPayload;
+  meeting: any;
+}) => {
   const {transcriptId} = data;
   const transcriptData = meeting.transcription;
 
-  if (data.isFinal) {
-    transcriptData.interimCaptions[transcriptId].forEach((interimId) => {
-      const interimTranscriptIndex = transcriptData.captions.findIndex(
-        (transcript) => transcript.id === interimId
-      );
-
-      if (interimTranscriptIndex !== -1) {
-        transcriptData.captions.splice(interimTranscriptIndex, 1);
-      }
-    });
-    delete transcriptData.interimCaptions[transcriptId];
-    const csisKey = data.transcript?.csis[0];
-
-    const {needsCaching, speaker} = getSpeakerFromProxyOrStore({
-      meetingMembers: meeting.members.membersCollection.members,
-      transcriptData,
-      csisKey,
-    });
-
-    if (needsCaching) {
-      transcriptData.speakerProxy[csisKey] = speaker;
-    }
-    const captionData = {
-      id: transcriptId,
-      isFinal: data.isFinal,
-      translations: data.translations,
-      text: data.transcript?.text,
-      currentSpokenLanguage: data.transcript?.transcript_language_code,
-      timestamp: data.timestamp,
-      speaker,
-    };
-    transcriptData.captions.push(captionData);
-  }
   const {transcripts = []} = data;
   const transcriptsPerCsis = new Map();
 
@@ -80,8 +55,11 @@ export const processNewCaptions = ({data, meeting}) => {
 
     const newCaption = `${transcriptsPerCsis.get(csisMember)?.text ?? ''} ${text}`.trim();
 
-    // eslint-disable-next-line camelcase
-    transcriptsPerCsis.set(csisMember, {text: newCaption, currentSpokenLanguage});
+    transcriptsPerCsis.set(csisMember, {
+      ...transcript,
+      text: newCaption,
+      currentSpokenLanguage,
+    });
   }
   const interimTranscriptionIds = [];
 
@@ -91,31 +69,51 @@ export const processNewCaptions = ({data, meeting}) => {
       transcriptData,
       csisKey: key,
     });
+    const {speakerId} = speaker;
+    const interimId = `${transcriptId}_${speakerId}`;
 
     if (needsCaching) {
       transcriptData.speakerProxy[key] = speaker;
     }
-    const {speakerId} = speaker;
-    const interimId = `${transcriptId}_${speakerId}`;
+
     const captionData = {
       id: interimId,
       isFinal: data.isFinal,
       translations: value.translations,
       text: value.text,
-      currentCaptionLanguage: value.currentSpokenLanguage,
+      currentCaptionLanguage:
+        meeting.transcription?.languageOptions?.currentCaptionLanguage ||
+        value.currentSpokenLanguage,
+      currentSpokenLanguage:
+        meeting.transcription?.languageOptions?.currentSpokenLanguage ||
+        data.transcripts[0]?.transcript_language_code,
       timestamp: value?.timestamp,
       speaker,
     };
 
-    const interimTranscriptIndex = transcriptData.captions.findIndex(
-      (transcript) => transcript.id === interimId
-    );
+    if (!data.isFinal) {
+      const interimTranscriptIndex = transcriptData.captions.findIndex(
+        (transcript) => transcript.id === interimId
+      );
 
-    if (interimTranscriptIndex !== -1) {
-      transcriptData.captions.splice(interimTranscriptIndex, 1);
-    }
+      if (interimTranscriptIndex !== -1) {
+        transcriptData.captions.splice(interimTranscriptIndex, 1);
+      }
 
-    interimTranscriptionIds.push(interimId);
+      interimTranscriptionIds.push(interimId);
+    } else {
+      transcriptData.interimCaptions[transcriptId].forEach((innerInterimId) => {
+        const interimTranscriptIndex = transcriptData.captions.findIndex(
+          (transcript) => transcript.id === innerInterimId
+        );
+
+        if (interimTranscriptIndex !== -1) {
+          transcriptData.captions.splice(interimTranscriptIndex, 1);
+        }
+      });
+      delete transcriptData.interimCaptions[transcriptId];
+      captionData.id = transcriptId;
+    }
     transcriptData.captions.push(captionData);
   }
   transcriptData.interimCaptions[transcriptId] = interimTranscriptionIds;

package/src/meeting-info/util.ts

@@ -33,282 +33,290 @@ import {
   UUID_REG,
 } from '../constants';
 
-const MeetingInfoUtil: any = {};
-
-MeetingInfoUtil.extractDestination = (destination, type) => {
-  let dest = destination;
-
-  if (type === _LOCUS_ID_) {
-    if (!(destination && destination.url)) {
-      throw new ParameterError('You cannot create a meeting by locus without a locus.url defined');
+/**
+ * @class MeetingInfoUtil
+ */
+export default class MeetingInfoUtil {
+  static extractDestination(destination, type) {
+    let dest = destination;
+
+    if (type === _LOCUS_ID_) {
+      if (!(destination && destination.url)) {
+        throw new ParameterError(
+          'You cannot create a meeting by locus without a locus.url defined'
+        );
+      }
+      dest = destination.url;
     }
-    dest = destination.url;
+
+    return dest;
   }
 
-  return dest;
-};
+  static getParsedUrl(link) {
+    try {
+      let parsedUrl = url.parse(link);
+
+      if (!parsedUrl) {
+        return false;
+      }
+      // hack for links such as <company>.webex.com/meet/<user> without a protocol
+      if (!parsedUrl.protocol) {
+        parsedUrl = url.parse(`${HTTPS_PROTOCOL}${link}`);
+      }
 
-MeetingInfoUtil.getParsedUrl = (link) => {
-  try {
-    let parsedUrl = url.parse(link);
+      return parsedUrl;
+    } catch (error) {
+      LoggerProxy.logger.warn(
+        `Meeting-info:util#getParsedUrl --> unable to parse the URL, error: ${error}`
+      );
 
-    if (!parsedUrl) {
-      return false;
-    }
-    // hack for links such as <company>.webex.com/meet/<user> without a protocol
-    if (!parsedUrl.protocol) {
-      parsedUrl = url.parse(`${HTTPS_PROTOCOL}${link}`);
+      return null;
     }
+  }
 
-    return parsedUrl;
-  } catch (error) {
-    LoggerProxy.logger.warn(
-      `Meeting-info:util#getParsedUrl --> unable to parse the URL, error: ${error}`
-    );
+  /**
+   * Helper function to check if a string matches a known meeting link pattern
+   * @param {String} value  string to parse and see if it matches a meeting link
+   * @returns {Boolean}
+   */
+  static isMeetingLink(value: string) {
+    const parsedUrl = this.getParsedUrl(value);
+    let hostNameBool;
+    let pathNameBool;
+    if (parsedUrl) {
+      hostNameBool = parsedUrl.hostname && parsedUrl.hostname.includes(WEBEX_DOT_COM);
+      pathNameBool =
+        parsedUrl.pathname &&
+        (parsedUrl.pathname.includes(`/${MEET}`) ||
+          parsedUrl.pathname.includes(`/${MEET_M}`) ||
+          parsedUrl.pathname.includes(`/${JOIN}`));
+    }
 
-    return null;
+    return hostNameBool && pathNameBool;
   }
-};
 
-/**
- * Helper function to check if a string matches a known meeting link pattern
- * @param {String} value  string to parse and see if it matches a meeting link
- * @returns {Boolean}
- */
-MeetingInfoUtil.isMeetingLink = (value: string) => {
-  const parsedUrl = MeetingInfoUtil.getParsedUrl(value);
-  const hostNameBool = parsedUrl.hostname && parsedUrl.hostname.includes(WEBEX_DOT_COM);
-  const pathNameBool =
-    parsedUrl.pathname &&
-    (parsedUrl.pathname.includes(`/${MEET}`) ||
-      parsedUrl.pathname.includes(`/${MEET_M}`) ||
-      parsedUrl.pathname.includes(`/${JOIN}`));
-
-  return hostNameBool && pathNameBool;
-};
-
-MeetingInfoUtil.isConversationUrl = (value, webex) => {
-  const clusterId = webex.internal.services.getClusterId(value);
-
-  if (clusterId) {
-    return clusterId.endsWith(CONVERSATION_SERVICE);
+  static isConversationUrl(value, webex) {
+    const clusterId = webex.internal.services.getClusterId(value);
+
+    if (clusterId) {
+      return clusterId.endsWith(CONVERSATION_SERVICE);
+    }
+
+    return false;
   }
 
-  return false;
-};
+  static convertLinkToSip(value) {
+    const parsedUrl = this.getParsedUrl(value);
 
-MeetingInfoUtil.convertLinkToSip = (value) => {
-  const parsedUrl = MeetingInfoUtil.getParsedUrl(value);
+    if (!parsedUrl) {
+      return null;
+    }
+    let user;
 
-  if (!parsedUrl) {
-    return null;
-  }
-  let user;
+    if (parsedUrl.pathname) {
+      const userIndex = parsedUrl.pathname.lastIndexOf('/');
 
-  if (parsedUrl.pathname) {
-    const userIndex = parsedUrl.pathname.lastIndexOf('/');
+      user = parsedUrl.pathname.substring(userIndex + 1);
+    }
+    if (!user) {
+      return null;
+    }
+    let company;
 
-    user = parsedUrl.pathname.substring(userIndex + 1);
-  }
-  if (!user) {
-    return null;
-  }
-  let company;
+    if (parsedUrl.hostname) {
+      const companyIndex = parsedUrl.hostname.lastIndexOf(`.${WEBEX_DOT_COM}`);
 
-  if (parsedUrl.hostname) {
-    const companyIndex = parsedUrl.hostname.lastIndexOf(`.${WEBEX_DOT_COM}`);
+      company = parsedUrl.hostname.substring(0, companyIndex).replace(WWW_DOT, '');
+    }
+    if (!company) {
+      return null;
+    }
 
-    company = parsedUrl.hostname.substring(0, companyIndex).replace(WWW_DOT, '');
-  }
-  if (!company) {
-    return null;
+    return `${user}@${company}.${WEBEX_DOT_COM}`;
   }
 
-  return `${user}@${company}.${WEBEX_DOT_COM}`;
-};
+  static isSipUri(sipString) {
+    // TODO: lets remove regex from this equation and user URI matchers and such
+    // have not found a great sip uri parser library as of now
+    const sipUri = DIALER_REGEX.SIP_ADDRESS.exec(sipString);
 
-MeetingInfoUtil.isSipUri = (sipString) => {
-  // TODO: lets remove regex from this equation and user URI matchers and such
-  // have not found a great sip uri parser library as of now
-  const sipUri = DIALER_REGEX.SIP_ADDRESS.exec(sipString);
+    return sipUri;
+  }
 
-  return sipUri;
-};
+  static isPhoneNumber(phoneNumber) {
+    const isValidNumber = DIALER_REGEX.PHONE_NUMBER.test(phoneNumber);
 
-MeetingInfoUtil.isPhoneNumber = (phoneNumber) => {
-  const isValidNumber = DIALER_REGEX.PHONE_NUMBER.test(phoneNumber);
+    return isValidNumber;
+  }
 
-  return isValidNumber;
-};
+  static getHydraId(destination) {
+    const {type, id, cluster} = deconstructHydraId(destination);
 
-MeetingInfoUtil.getHydraId = (destination) => {
-  const {type, id, cluster} = deconstructHydraId(destination);
+    if (id && UUID_REG.test(id)) {
+      if (type === _ROOM_) {
+        return {room: true, destination: id, cluster};
+      }
+      if (type === _PEOPLE_) {
+        return {people: true, destination: id, cluster};
+      }
 
-  if (id && UUID_REG.test(id)) {
-    if (type === _ROOM_) {
-      return {room: true, destination: id, cluster};
-    }
-    if (type === _PEOPLE_) {
-      return {people: true, destination: id, cluster};
+      return {};
     }
 
     return {};
   }
 
-  return {};
-};
-
-MeetingInfoUtil.getSipUriFromHydraPersonId = (destination, webex) =>
-  webex.people
-    .get(destination)
-    .then((res) => {
-      if (res.emails && res.emails.length) {
-        return res.emails[0];
-      }
-      throw new ParameterError('Hydra Id Lookup was an invalid hydra person id.');
-    })
-    .catch((err) => {
-      LoggerProxy.logger.error(
-        `Meeting-info:util#MeetingInfoUtil.getSipUriFromHydraPersonId --> getSipUriFromHydraPersonId ${err} `
-      );
-      throw err;
-    });
+  static getSipUriFromHydraPersonId(destination, webex) {
+    return webex.people
+      .get(destination)
+      .then((res) => {
+        if (res.emails && res.emails.length) {
+          return res.emails[0];
+        }
+        throw new ParameterError('Hydra Id Lookup was an invalid hydra person id.');
+      })
+      .catch((err) => {
+        LoggerProxy.logger.error(
+          `Meeting-info:util#MeetingInfoUtil.getSipUriFromHydraPersonId --> getSipUriFromHydraPersonId ${err} `
+        );
+        throw err;
+      });
+  }
 
-MeetingInfoUtil.generateOptions = async (from) => {
-  const {destination, type, webex} = from;
+  static async generateOptions(from) {
+    const {destination, type, webex} = from;
 
-  if (type) {
-    return {
-      destination,
-      type,
-    };
-  }
-  const options: any = {};
-  const hydraId = MeetingInfoUtil.getHydraId(destination);
-
-  if (MeetingInfoUtil.isMeetingLink(destination)) {
-    LoggerProxy.logger.warn(
-      'Meeting-info:util#generateOptions --> WARN, use of Meeting Link is deprecated, please use a SIP URI instead'
-    );
-
-    options.type = _MEETING_LINK_;
-    options.destination = destination;
-  } else if (MeetingInfoUtil.isSipUri(destination)) {
-    options.type = _SIP_URI_;
-    options.destination = destination;
-  } else if (MeetingInfoUtil.isPhoneNumber(destination)) {
-    options.type = _SIP_URI_;
-    options.destination = destination;
-  } else if (MeetingInfoUtil.isConversationUrl(destination, webex)) {
-    options.type = _CONVERSATION_URL_;
-    options.destination = destination;
-  } else if (hydraId.people) {
-    options.type = _SIP_URI_;
-
-    return MeetingInfoUtil.getSipUriFromHydraPersonId(hydraId.destination, webex).then((res) => {
-      options.destination = res;
-
-      // Since hydra person ids require a unique case in which they are
-      // entirely converted to a SIP URI, we need to set a flag for detecting
-      // this type of destination.
-      options.wasHydraPerson = true;
-
-      return Promise.resolve(options);
-    });
-  } else if (hydraId.room) {
-    options.type = _CONVERSATION_URL_;
-    try {
-      await webex.internal.services.waitForCatalog('postauth');
+    if (type) {
+      return {
+        destination,
+        type,
+      };
+    }
+    const options: any = {};
+    const hydraId = this.getHydraId(destination);
 
-      const serviceUrl = webex.internal.services.getServiceUrlFromClusterId(
-        {
-          cluster: hydraId.cluster,
-        },
-        webex
+    if (this.isMeetingLink(destination)) {
+      LoggerProxy.logger.warn(
+        'Meeting-info:util#generateOptions --> WARN, use of Meeting Link is deprecated, please use a SIP URI instead'
       );
 
-      options.destination = hydraId.destination
-        ? `${serviceUrl}/conversations/${hydraId.destination}`
-        : serviceUrl;
-    } catch (e) {
-      LoggerProxy.logger.error(`Meeting-info:util#generateOptions --> ${e}`);
-      throw e;
+      options.type = _MEETING_LINK_;
+      options.destination = destination;
+    } else if (this.isSipUri(destination)) {
+      options.type = _SIP_URI_;
+      options.destination = destination;
+    } else if (this.isPhoneNumber(destination)) {
+      options.type = _SIP_URI_;
+      options.destination = destination;
+    } else if (this.isConversationUrl(destination, webex)) {
+      options.type = _CONVERSATION_URL_;
+      options.destination = destination;
+    } else if (hydraId.people) {
+      options.type = _SIP_URI_;
+
+      return this.getSipUriFromHydraPersonId(hydraId.destination, webex).then((res) => {
+        options.destination = res;
+
+        // Since hydra person ids require a unique case in which they are
+        // entirely converted to a SIP URI, we need to set a flag for detecting
+        // this type of destination.
+        options.wasHydraPerson = true;
+
+        return Promise.resolve(options);
+      });
+    } else if (hydraId.room) {
+      options.type = _CONVERSATION_URL_;
+      try {
+        await webex.internal.services.waitForCatalog('postauth');
+
+        const serviceUrl = webex.internal.services.getServiceUrlFromClusterId(
+          {
+            cluster: hydraId.cluster,
+          },
+          webex
+        );
+
+        options.destination = hydraId.destination
+          ? `${serviceUrl}/conversations/${hydraId.destination}`
+          : serviceUrl;
+      } catch (e) {
+        LoggerProxy.logger.error(`Meeting-info:util#generateOptions --> ${e}`);
+        throw e;
+      }
+    } else {
+      throw new ParameterError(
+        'MeetingInfo is fetched with the meeting link, SIP URI, phone number, Hydra people ID, or a conversation URL.'
+      );
     }
-  } else {
-    throw new ParameterError(
-      'MeetingInfo is fetched with the meeting link, SIP URI, phone number, Hydra people ID, or a conversation URL.'
-    );
+
+    return Promise.resolve(options);
   }
 
-  return Promise.resolve(options);
-};
+  /**
+   * Helper function to build up a correct locus url depending on the value passed
+   * @param {String} type One of [SIP_URI, PERSONAL_ROOM, MEETING_ID, CONVERSATION_URL, LOCUS_ID, MEETING_LINK]
+   * @param {Object} value ?? value.value
+   * @returns {Object} returns an object with {resource, method}
+   */
+  static getResourceUrl(type: string, value: any) {
+    let resource = `/${LOCI}/${MEETINGINFO}`;
+    let method = HTTP_VERBS.GET;
+    let uri = null;
+
+    switch (type) {
+      case _SIP_URI_:
+      case _PERSONAL_ROOM_:
+      case _MEETING_ID_:
+        resource = `/${LOCI}/${MEETINGINFO}/${encodeURIComponent(
+          value
+        )}?${TYPE}=${type}&${USE_URI_LOOKUP_FALSE}`;
+        break;
+      case _CONVERSATION_URL_:
+        method = HTTP_VERBS.PUT;
+        break;
+      case _LOCUS_ID_:
+        uri = `${value}/${MEETINGINFO}`;
+        method = HTTP_VERBS.PUT;
+        break;
+      case _MEETING_LINK_:
+        resource = `$/${LOCI}/${MEETINGINFO}/${btoa(
+          value
+        )}?${TYPE}=${_MEETING_LINK_}&${USE_URI_LOOKUP_FALSE}`;
+        break;
+      default:
+    }
 
-/**
- * Helper function to build up a correct locus url depending on the value passed
- * @param {String} type One of [SIP_URI, PERSONAL_ROOM, MEETING_ID, CONVERSATION_URL, LOCUS_ID, MEETING_LINK]
- * @param {Object} value ?? value.value
- * @returns {Object} returns an object with {resource, method}
- */
-MeetingInfoUtil.getResourceUrl = (type: string, value: any) => {
-  let resource = `/${LOCI}/${MEETINGINFO}`;
-  let method = HTTP_VERBS.GET;
-  let uri = null;
-
-  switch (type) {
-    case _SIP_URI_:
-    case _PERSONAL_ROOM_:
-    case _MEETING_ID_:
-      resource = `/${LOCI}/${MEETINGINFO}/${encodeURIComponent(
-        value
-      )}?${TYPE}=${type}&${USE_URI_LOOKUP_FALSE}`;
-      break;
-    case _CONVERSATION_URL_:
-      method = HTTP_VERBS.PUT;
-      break;
-    case _LOCUS_ID_:
-      uri = `${value}/${MEETINGINFO}`;
-      method = HTTP_VERBS.PUT;
-      break;
-    case _MEETING_LINK_:
-      resource = `$/${LOCI}/${MEETINGINFO}/${btoa(
-        value
-      )}?${TYPE}=${_MEETING_LINK_}&${USE_URI_LOOKUP_FALSE}`;
-      break;
-    default:
+    return {
+      uri,
+      resource,
+      method,
+    };
   }
 
-  return {
-    uri,
-    resource,
-    method,
-  };
-};
-
-MeetingInfoUtil.getRequestParams = (resourceOptions, type, value, api) => {
-  let requestParams: any = {
-    method: resourceOptions.method,
-    api,
-    resource: resourceOptions.resource,
-  };
-
-  if (resourceOptions.method === HTTP_VERBS.GET) {
-    // for handling URL redirections
-    requestParams.resource = requestParams.resource.concat(`&${ALTERNATE_REDIRECT_TRUE}`);
-  } else if (type !== _LOCUS_ID_) {
-    // locus id check is a PUT not sure why
-    requestParams.resource = requestParams.resource.concat(`?${ALTERNATE_REDIRECT_TRUE}`);
-    requestParams.body = {
-      value,
-      lookupType: type,
-    };
-  } else if (type === _LOCUS_ID_) {
-    requestParams = {
+  static getRequestParams(resourceOptions, type, value, api) {
+    let requestParams: any = {
       method: resourceOptions.method,
-      uri: resourceOptions.uri,
+      api,
+      resource: resourceOptions.resource,
     };
-  }
 
-  return requestParams;
-};
+    if (resourceOptions.method === HTTP_VERBS.GET) {
+      // for handling URL redirections
+      requestParams.resource = requestParams.resource.concat(`&${ALTERNATE_REDIRECT_TRUE}`);
+    } else if (type !== _LOCUS_ID_) {
+      // locus id check is a PUT not sure why
+      requestParams.resource = requestParams.resource.concat(`?${ALTERNATE_REDIRECT_TRUE}`);
+      requestParams.body = {
+        value,
+        lookupType: type,
+      };
+    } else if (type === _LOCUS_ID_) {
+      requestParams = {
+        method: resourceOptions.method,
+        uri: resourceOptions.uri,
+      };
+    }
 
-export default MeetingInfoUtil;
+    return requestParams;
+  }
+}