@azure/communication-call-automation/dist/commonjs/utli/converters.js

Azure client library for Azure Communication Call Automation services

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var converters_exports = {};
__export(converters_exports, {
  PhoneNumberIdentifierModelConverter: () => PhoneNumberIdentifierModelConverter,
  callParticipantConverter: () => callParticipantConverter,
  communicationIdentifierConverter: () => communicationIdentifierConverter,
  communicationIdentifierModelConverter: () => communicationIdentifierModelConverter,
  communicationUserIdentifierConverter: () => communicationUserIdentifierConverter,
  communicationUserIdentifierModelConverter: () => communicationUserIdentifierModelConverter,
  microsoftTeamsAppIdentifierConverter: () => microsoftTeamsAppIdentifierConverter,
  microsoftTeamsAppIdentifierModelConverter: () => microsoftTeamsAppIdentifierModelConverter,
  phoneNumberIdentifierConverter: () => phoneNumberIdentifierConverter,
  teamsPhoneCallDetailsConverter: () => teamsPhoneCallDetailsConverter,
  teamsPhoneCallDetailsModelConverter: () => teamsPhoneCallDetailsModelConverter,
  teamsPhoneCallerDetailsConverter: () => teamsPhoneCallerDetailsConverter,
  teamsPhoneCallerDetailsModelConverter: () => teamsPhoneCallerDetailsModelConverter,
  teamsPhoneSourceDetailsConverter: () => teamsPhoneSourceDetailsConverter,
  teamsPhoneSourceDetailsModelConverter: () => teamsPhoneSourceDetailsModelConverter
});
module.exports = __toCommonJS(converters_exports);
var import_communication_common = require("@azure/communication-common");
var import_src = require("../generated/src/index.js");
function extractKind(identifierModel) {
  if (identifierModel.communicationUser !== void 0) {
    return import_src.KnownCommunicationIdentifierModelKind.CommunicationUser;
  }
  if (identifierModel.phoneNumber !== void 0) {
    return import_src.KnownCommunicationIdentifierModelKind.PhoneNumber;
  }
  if (identifierModel.microsoftTeamsUser !== void 0) {
    return import_src.KnownCommunicationIdentifierModelKind.MicrosoftTeamsUser;
  }
  if (identifierModel.microsoftTeamsApp !== void 0) {
    return import_src.KnownCommunicationIdentifierModelKind.MicrosoftTeamsApp;
  }
  if (identifierModel.teamsExtensionUser !== void 0) {
    return import_src.KnownCommunicationIdentifierModelKind.TeamsExtensionUser;
  }
  return import_src.KnownCommunicationIdentifierModelKind.Unknown;
}
function PhoneNumberIdentifierModelConverter(phoneNumberIdentifier) {
  if (phoneNumberIdentifier === void 0 || phoneNumberIdentifier.phoneNumber === void 0) {
    return void 0;
  }
  const phoneNumberIdentifierModel = (0, import_communication_common.serializeCommunicationIdentifier)(phoneNumberIdentifier).phoneNumber;
  return phoneNumberIdentifierModel;
}
function phoneNumberIdentifierConverter(serializedPhoneNumberIdentifier) {
  if (serializedPhoneNumberIdentifier === void 0 || serializedPhoneNumberIdentifier?.value === null) {
    return void 0;
  }
  const phoneNumberIdentifier = {
    phoneNumber: serializedPhoneNumberIdentifier.value
  };
  return phoneNumberIdentifier;
}
function communicationIdentifierConverter(identifierModel) {
  const rawId = identifierModel.rawId;
  const kind = identifierModel.kind !== void 0 ? identifierModel.kind : extractKind(identifierModel);
  if (kind === import_src.KnownCommunicationIdentifierModelKind.CommunicationUser && identifierModel.communicationUser !== void 0) {
    const communicationUserIdentifier = {
      communicationUserId: identifierModel.communicationUser.id
    };
    return communicationUserIdentifier;
  }
  if (kind === import_src.KnownCommunicationIdentifierModelKind.PhoneNumber && identifierModel.phoneNumber !== void 0) {
    const phoneNumberIdentifier = {
      phoneNumber: identifierModel.phoneNumber.value,
      rawId
    };
    return phoneNumberIdentifier;
  }
  if (kind === import_src.KnownCommunicationIdentifierModelKind.MicrosoftTeamsUser && identifierModel.microsoftTeamsUser !== void 0) {
    const microsoftTeamsUserIdentifier = {
      rawId,
      microsoftTeamsUserId: identifierModel.microsoftTeamsUser.userId,
      isAnonymous: identifierModel.microsoftTeamsUser.isAnonymous,
      cloud: identifierModel.microsoftTeamsUser.cloud
    };
    return microsoftTeamsUserIdentifier;
  }
  if (kind === import_src.KnownCommunicationIdentifierModelKind.MicrosoftTeamsApp && identifierModel.microsoftTeamsApp !== void 0) {
    const microsoftTeamsAppIdentifier = {
      rawId,
      teamsAppId: identifierModel.microsoftTeamsApp.appId,
      cloud: identifierModel.microsoftTeamsApp.cloud
    };
    return microsoftTeamsAppIdentifier;
  }
  if (kind === import_src.KnownCommunicationIdentifierModelKind.TeamsExtensionUser && identifierModel.teamsExtensionUser !== void 0) {
    const teamsExtensionUserIdentifier = {
      rawId,
      userId: identifierModel.teamsExtensionUser.userId,
      resourceId: identifierModel.teamsExtensionUser.resourceId,
      tenantId: identifierModel.teamsExtensionUser.tenantId,
      cloud: identifierModel.teamsExtensionUser.cloud
    };
    return teamsExtensionUserIdentifier;
  }
  const unknownIdentifier = {
    id: rawId ? rawId : ""
  };
  return unknownIdentifier;
}
function communicationIdentifierModelConverter(identifier) {
  const serializedIdentifier = (0, import_communication_common.serializeCommunicationIdentifier)(identifier);
  if ((0, import_communication_common.isCommunicationUserIdentifier)(identifier)) {
    const communicationUserIdentifierModel = {
      kind: import_src.KnownCommunicationIdentifierModelKind.CommunicationUser,
      ...serializedIdentifier
    };
    return communicationUserIdentifierModel;
  }
  if ((0, import_communication_common.isPhoneNumberIdentifier)(identifier)) {
    const phoneNumberIdentifierModel = {
      kind: import_src.KnownCommunicationIdentifierModelKind.PhoneNumber,
      ...serializedIdentifier
    };
    return phoneNumberIdentifierModel;
  }
  if ((0, import_communication_common.isMicrosoftTeamsUserIdentifier)(identifier)) {
    const microsoftTeamsUserIdentifierModel = {
      kind: import_src.KnownCommunicationIdentifierModelKind.MicrosoftTeamsUser,
      ...serializedIdentifier
    };
    return microsoftTeamsUserIdentifierModel;
  }
  if ((0, import_communication_common.isMicrosoftTeamsAppIdentifier)(identifier)) {
    const microsoftTeamsAppIdentifierModel = {
      kind: import_src.KnownCommunicationIdentifierModelKind.MicrosoftTeamsApp,
      ...serializedIdentifier
    };
    return microsoftTeamsAppIdentifierModel;
  }
  if ((0, import_communication_common.isTeamsExtensionUserIdentifier)(identifier)) {
    const teamsExtensionUserIdentifierModel = {
      kind: import_src.KnownCommunicationIdentifierModelKind.TeamsExtensionUser,
      ...serializedIdentifier
    };
    return teamsExtensionUserIdentifierModel;
  }
  if ((0, import_communication_common.isUnknownIdentifier)(identifier)) {
    const unknownIdentifierModel = {
      kind: import_src.KnownCommunicationIdentifierModelKind.Unknown,
      ...serializedIdentifier
    };
    return unknownIdentifierModel;
  }
  throw new Error();
}
function callParticipantConverter(acsCallParticipant) {
  const callParticipant = {
    ...acsCallParticipant,
    identifier: acsCallParticipant.identifier ? communicationIdentifierConverter(acsCallParticipant.identifier) : void 0
  };
  return callParticipant;
}
function communicationUserIdentifierModelConverter(identifier) {
  if (!identifier || !identifier.communicationUserId) {
    return void 0;
  }
  return { id: identifier.communicationUserId };
}
function communicationUserIdentifierConverter(identifier) {
  if (!identifier || !identifier.id) {
    return void 0;
  }
  return { communicationUserId: identifier.id };
}
function microsoftTeamsAppIdentifierModelConverter(identifier) {
  if (!identifier || !identifier.teamsAppId) {
    return void 0;
  }
  return { appId: identifier.teamsAppId };
}
function microsoftTeamsAppIdentifierConverter(identifier) {
  if (!identifier || !identifier.appId) {
    return void 0;
  }
  return { teamsAppId: identifier.appId };
}
function teamsPhoneCallerDetailsModelConverter(teamsPhoneCallerDetails) {
  if (!teamsPhoneCallerDetails) {
    return void 0;
  }
  return {
    caller: communicationIdentifierModelConverter(teamsPhoneCallerDetails.caller),
    name: teamsPhoneCallerDetails.name,
    phoneNumber: teamsPhoneCallerDetails.phoneNumber,
    recordId: teamsPhoneCallerDetails.recordId,
    screenPopUrl: teamsPhoneCallerDetails.screenPopUrl,
    isAuthenticated: teamsPhoneCallerDetails.isAuthenticated,
    additionalCallerInformation: teamsPhoneCallerDetails.additionalCallerInformation
  };
}
function teamsPhoneSourceDetailsModelConverter(teamsPhoneSourceDetails) {
  if (!teamsPhoneSourceDetails) {
    return void 0;
  }
  const intendedTargets = {};
  if (teamsPhoneSourceDetails.intendedTargets) {
    for (const [key, value] of Object.entries(teamsPhoneSourceDetails.intendedTargets)) {
      intendedTargets[key] = communicationIdentifierModelConverter(value);
    }
  }
  return {
    source: communicationIdentifierModelConverter(teamsPhoneSourceDetails.source),
    language: teamsPhoneSourceDetails.language,
    status: teamsPhoneSourceDetails.status,
    intendedTargets: Object.keys(intendedTargets).length > 0 ? intendedTargets : void 0
  };
}
function teamsPhoneCallDetailsModelConverter(teamsPhoneCallDetails) {
  if (!teamsPhoneCallDetails) {
    return void 0;
  }
  return {
    teamsPhoneCallerDetails: teamsPhoneCallerDetailsModelConverter(
      teamsPhoneCallDetails.teamsPhoneCallerDetails
    ),
    teamsPhoneSourceDetails: teamsPhoneSourceDetailsModelConverter(
      teamsPhoneCallDetails.teamsPhoneSourceDetails
    ),
    sessionId: teamsPhoneCallDetails.sessionId,
    intent: teamsPhoneCallDetails.intent,
    callTopic: teamsPhoneCallDetails.callTopic,
    callContext: teamsPhoneCallDetails.callContext,
    transcriptUrl: teamsPhoneCallDetails.transcriptUrl,
    callSentiment: teamsPhoneCallDetails.callSentiment,
    suggestedActions: teamsPhoneCallDetails.suggestedActions
  };
}
function teamsPhoneCallerDetailsConverter(teamsPhoneCallerDetails) {
  if (!teamsPhoneCallerDetails) {
    return void 0;
  }
  return {
    caller: communicationIdentifierConverter(teamsPhoneCallerDetails.caller),
    name: teamsPhoneCallerDetails.name,
    phoneNumber: teamsPhoneCallerDetails.phoneNumber,
    recordId: teamsPhoneCallerDetails.recordId,
    screenPopUrl: teamsPhoneCallerDetails.screenPopUrl,
    isAuthenticated: teamsPhoneCallerDetails.isAuthenticated,
    additionalCallerInformation: teamsPhoneCallerDetails.additionalCallerInformation
  };
}
function teamsPhoneSourceDetailsConverter(teamsPhoneSourceDetails) {
  if (!teamsPhoneSourceDetails) {
    return void 0;
  }
  const intendedTargets = {};
  if (teamsPhoneSourceDetails.intendedTargets) {
    for (const [key, value] of Object.entries(teamsPhoneSourceDetails.intendedTargets)) {
      intendedTargets[key] = communicationIdentifierConverter(
        value
      );
    }
  }
  return {
    source: communicationIdentifierConverter(teamsPhoneSourceDetails.source),
    language: teamsPhoneSourceDetails.language,
    status: teamsPhoneSourceDetails.status,
    intendedTargets: Object.keys(intendedTargets).length > 0 ? intendedTargets : void 0
  };
}
function teamsPhoneCallDetailsConverter(teamsPhoneCallDetails) {
  if (!teamsPhoneCallDetails) {
    return void 0;
  }
  return {
    kind: "TeamsPhoneCallDetails",
    teamsPhoneCallerDetails: teamsPhoneCallerDetailsConverter(
      teamsPhoneCallDetails.teamsPhoneCallerDetails
    ),
    teamsPhoneSourceDetails: teamsPhoneSourceDetailsConverter(
      teamsPhoneCallDetails.teamsPhoneSourceDetails
    ),
    sessionId: teamsPhoneCallDetails.sessionId,
    intent: teamsPhoneCallDetails.intent,
    callTopic: teamsPhoneCallDetails.callTopic,
    callContext: teamsPhoneCallDetails.callContext,
    transcriptUrl: teamsPhoneCallDetails.transcriptUrl,
    callSentiment: teamsPhoneCallDetails.callSentiment,
    suggestedActions: teamsPhoneCallDetails.suggestedActions
  };
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  PhoneNumberIdentifierModelConverter,
  callParticipantConverter,
  communicationIdentifierConverter,
  communicationIdentifierModelConverter,
  communicationUserIdentifierConverter,
  communicationUserIdentifierModelConverter,
  microsoftTeamsAppIdentifierConverter,
  microsoftTeamsAppIdentifierModelConverter,
  phoneNumberIdentifierConverter,
  teamsPhoneCallDetailsConverter,
  teamsPhoneCallDetailsModelConverter,
  teamsPhoneCallerDetailsConverter,
  teamsPhoneCallerDetailsModelConverter,
  teamsPhoneSourceDetailsConverter,
  teamsPhoneSourceDetailsModelConverter
});
//# sourceMappingURL=converters.js.map