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

Azure client library for Azure Communication Call Automation services

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
import { serializeCommunicationIdentifier, isCommunicationUserIdentifier, isPhoneNumberIdentifier, isUnknownIdentifier, isMicrosoftTeamsUserIdentifier, isMicrosoftTeamsAppIdentifier, isTeamsExtensionUserIdentifier, } from "@azure/communication-common";
import { KnownCommunicationIdentifierModelKind } from "../generated/src/index.js";
function extractKind(identifierModel) {
    if (identifierModel.communicationUser !== undefined) {
        return KnownCommunicationIdentifierModelKind.CommunicationUser;
    }
    if (identifierModel.phoneNumber !== undefined) {
        return KnownCommunicationIdentifierModelKind.PhoneNumber;
    }
    if (identifierModel.microsoftTeamsUser !== undefined) {
        return KnownCommunicationIdentifierModelKind.MicrosoftTeamsUser;
    }
    if (identifierModel.microsoftTeamsApp !== undefined) {
        return KnownCommunicationIdentifierModelKind.MicrosoftTeamsApp;
    }
    if (identifierModel.teamsExtensionUser !== undefined) {
        return KnownCommunicationIdentifierModelKind.TeamsExtensionUser;
    }
    return KnownCommunicationIdentifierModelKind.Unknown;
}
/** Convert PhoneNumberIdentifier to PhoneNumberIdentifierModel(Internal usage class) */
export function PhoneNumberIdentifierModelConverter(phoneNumberIdentifier) {
    if (phoneNumberIdentifier === undefined || phoneNumberIdentifier.phoneNumber === undefined) {
        return undefined;
    }
    const phoneNumberIdentifierModel = serializeCommunicationIdentifier(phoneNumberIdentifier).phoneNumber;
    return phoneNumberIdentifierModel;
}
/** Convert SerializedPhoneNumberIdentifier to PhoneNumberIdentifier(Public usage class) */
export function phoneNumberIdentifierConverter(serializedPhoneNumberIdentifier) {
    if (serializedPhoneNumberIdentifier === undefined ||
        serializedPhoneNumberIdentifier?.value === null) {
        return undefined;
    }
    const phoneNumberIdentifier = {
        phoneNumber: serializedPhoneNumberIdentifier.value,
    };
    return phoneNumberIdentifier;
}
/** Convert CommunicationIdentifierModel to CommunicationIdentifier(Public usage class) */
export function communicationIdentifierConverter(identifierModel) {
    const rawId = identifierModel.rawId;
    const kind = identifierModel.kind !== undefined ? identifierModel.kind : extractKind(identifierModel);
    if (kind === KnownCommunicationIdentifierModelKind.CommunicationUser &&
        identifierModel.communicationUser !== undefined) {
        const communicationUserIdentifier = {
            communicationUserId: identifierModel.communicationUser.id,
        };
        return communicationUserIdentifier;
    }
    if (kind === KnownCommunicationIdentifierModelKind.PhoneNumber &&
        identifierModel.phoneNumber !== undefined) {
        const phoneNumberIdentifier = {
            phoneNumber: identifierModel.phoneNumber.value,
            rawId: rawId,
        };
        return phoneNumberIdentifier;
    }
    if (kind === KnownCommunicationIdentifierModelKind.MicrosoftTeamsUser &&
        identifierModel.microsoftTeamsUser !== undefined) {
        const microsoftTeamsUserIdentifier = {
            rawId: rawId,
            microsoftTeamsUserId: identifierModel.microsoftTeamsUser.userId,
            isAnonymous: identifierModel.microsoftTeamsUser.isAnonymous,
            cloud: identifierModel.microsoftTeamsUser.cloud,
        };
        return microsoftTeamsUserIdentifier;
    }
    if (kind === KnownCommunicationIdentifierModelKind.MicrosoftTeamsApp &&
        identifierModel.microsoftTeamsApp !== undefined) {
        const microsoftTeamsAppIdentifier = {
            rawId: rawId,
            teamsAppId: identifierModel.microsoftTeamsApp.appId,
            cloud: identifierModel.microsoftTeamsApp.cloud,
        };
        return microsoftTeamsAppIdentifier;
    }
    if (kind === KnownCommunicationIdentifierModelKind.TeamsExtensionUser &&
        identifierModel.teamsExtensionUser !== undefined) {
        const teamsExtensionUserIdentifier = {
            rawId: 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;
}
/** Convert CommunicationIdentifier to CommunicationIdentifierModel(Internal usage class) */
export function communicationIdentifierModelConverter(identifier) {
    const serializedIdentifier = serializeCommunicationIdentifier(identifier);
    if (isCommunicationUserIdentifier(identifier)) {
        const communicationUserIdentifierModel = {
            kind: KnownCommunicationIdentifierModelKind.CommunicationUser,
            ...serializedIdentifier,
        };
        return communicationUserIdentifierModel;
    }
    if (isPhoneNumberIdentifier(identifier)) {
        const phoneNumberIdentifierModel = {
            kind: KnownCommunicationIdentifierModelKind.PhoneNumber,
            ...serializedIdentifier,
        };
        return phoneNumberIdentifierModel;
    }
    if (isMicrosoftTeamsUserIdentifier(identifier)) {
        const microsoftTeamsUserIdentifierModel = {
            kind: KnownCommunicationIdentifierModelKind.MicrosoftTeamsUser,
            ...serializedIdentifier,
        };
        return microsoftTeamsUserIdentifierModel;
    }
    if (isMicrosoftTeamsAppIdentifier(identifier)) {
        const microsoftTeamsAppIdentifierModel = {
            kind: KnownCommunicationIdentifierModelKind.MicrosoftTeamsApp,
            ...serializedIdentifier,
        };
        return microsoftTeamsAppIdentifierModel;
    }
    if (isTeamsExtensionUserIdentifier(identifier)) {
        const teamsExtensionUserIdentifierModel = {
            kind: KnownCommunicationIdentifierModelKind.TeamsExtensionUser,
            ...serializedIdentifier,
        };
        return teamsExtensionUserIdentifierModel;
    }
    if (isUnknownIdentifier(identifier)) {
        const unknownIdentifierModel = {
            kind: KnownCommunicationIdentifierModelKind.Unknown,
            ...serializedIdentifier,
        };
        return unknownIdentifierModel;
    }
    throw new Error();
}
/** Convert CallParticipantInternal to CallParticipant */
export function callParticipantConverter(acsCallParticipant) {
    const callParticipant = {
        ...acsCallParticipant,
        identifier: acsCallParticipant.identifier
            ? communicationIdentifierConverter(acsCallParticipant.identifier)
            : undefined,
    };
    return callParticipant;
}
/** Convert CommunicationUserIdentifier to CommunicationUserIdentifierModel (Internal usage class) */
export function communicationUserIdentifierModelConverter(identifier) {
    if (!identifier || !identifier.communicationUserId) {
        return undefined;
    }
    return { id: identifier.communicationUserId };
}
/** Convert CommunicationUserIdentifierModel to CommunicationUserIdentifier (Public usage class) */
export function communicationUserIdentifierConverter(identifier) {
    if (!identifier || !identifier.id) {
        return undefined;
    }
    return { communicationUserId: identifier.id };
}
/** Convert MicrosoftTeamsAppIdentifier to MicrosoftTeamsAppIdentifierModel (Internal usage class) */
export function microsoftTeamsAppIdentifierModelConverter(identifier) {
    if (!identifier || !identifier.teamsAppId) {
        return undefined;
    }
    return { appId: identifier.teamsAppId };
}
/** Convert MicrosoftTeamsAppIdentifierModel to MicrosoftTeamsAppIdentifier (Public usage class) */
export function microsoftTeamsAppIdentifierConverter(identifier) {
    if (!identifier || !identifier.appId) {
        return undefined;
    }
    return { teamsAppId: identifier.appId };
}
/**
 * Converts from public TeamsPhoneCallerDetails to internal TeamsPhoneCallerDetailsModel
 */
export function teamsPhoneCallerDetailsModelConverter(teamsPhoneCallerDetails) {
    if (!teamsPhoneCallerDetails) {
        return undefined;
    }
    return {
        caller: communicationIdentifierModelConverter(teamsPhoneCallerDetails.caller),
        name: teamsPhoneCallerDetails.name,
        phoneNumber: teamsPhoneCallerDetails.phoneNumber,
        recordId: teamsPhoneCallerDetails.recordId,
        screenPopUrl: teamsPhoneCallerDetails.screenPopUrl,
        isAuthenticated: teamsPhoneCallerDetails.isAuthenticated,
        additionalCallerInformation: teamsPhoneCallerDetails.additionalCallerInformation,
    };
}
/**
 * Converts from public TeamsPhoneSourceDetails to internal TeamsPhoneSourceDetailsModel
 */
export function teamsPhoneSourceDetailsModelConverter(teamsPhoneSourceDetails) {
    if (!teamsPhoneSourceDetails) {
        return undefined;
    }
    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 : undefined,
    };
}
/**
 * Converts from public TeamsPhoneCallDetails to internal TeamsPhoneCallDetailsModel
 */
export function teamsPhoneCallDetailsModelConverter(teamsPhoneCallDetails) {
    if (!teamsPhoneCallDetails) {
        return undefined;
    }
    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,
    };
}
/**
 * Converts from internal TeamsPhoneCallerDetailsInternal to public TeamsPhoneCallerDetails (for incoming events)
 */
export function teamsPhoneCallerDetailsConverter(teamsPhoneCallerDetails) {
    if (!teamsPhoneCallerDetails) {
        return undefined;
    }
    return {
        caller: communicationIdentifierConverter(teamsPhoneCallerDetails.caller),
        name: teamsPhoneCallerDetails.name,
        phoneNumber: teamsPhoneCallerDetails.phoneNumber,
        recordId: teamsPhoneCallerDetails.recordId,
        screenPopUrl: teamsPhoneCallerDetails.screenPopUrl,
        isAuthenticated: teamsPhoneCallerDetails.isAuthenticated,
        additionalCallerInformation: teamsPhoneCallerDetails.additionalCallerInformation,
    };
}
/**
 * Converts from internal TeamsPhoneSourceDetailsInternal to public TeamsPhoneSourceDetails (for incoming events)
 */
export function teamsPhoneSourceDetailsConverter(teamsPhoneSourceDetails) {
    if (!teamsPhoneSourceDetails) {
        return undefined;
    }
    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 : undefined,
    };
}
/**
 * Converts from internal TeamsPhoneCallDetailsInternal to public TeamsPhoneCallDetails (for incoming events)
 */
export function teamsPhoneCallDetailsConverter(teamsPhoneCallDetails) {
    if (!teamsPhoneCallDetails) {
        return undefined;
    }
    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,
    };
}
//# sourceMappingURL=converters.js.map