@microsoft/teams.api/dist/clients/conversation/activity.mjs

<p> <a href="https://www.npmjs.com/package/@microsoft/teams.api" target="_blank"> <img src="https://img.shields.io/npm/v/@microsoft/teams.api/latest" /> </a> <a href="https://www.npmjs.com/package/@microsoft/teams.api?activeTab=code" t

import { Client } from '@microsoft/teams.common';
import { toActivityParams } from '../../activities/index.mjs';
import { OUTBOUND_OPERATIONS, API_ATTRIBUTE_NAMES } from '../../diagnostics/constants.mjs';
import { getPlanInfo, resolveAadObjectId } from '../../models/index.mjs';
import { mergeApiClientSettings } from '../api-client-settings.mjs';
import { ensureApiOutboundTelemetryMiddleware, withApiOutboundTelemetry } from '../api-outbound-middleware.mjs';
import { normalizeServiceUrl } from '../service-url.mjs';

function requireId(name, value) {
  if (typeof value !== "string" || value.trim() === "") {
    throw new Error(`${name} must be a non-empty string`);
  }
  if (value === "." || value === "..") {
    throw new Error(`${name} must not be a dot segment`);
  }
}
function apiOutboundTelemetryConfig(operation, serviceUrl, conversationId, activity, options) {
  return {
    extensions: withApiOutboundTelemetry({
      operation,
      attributes: {
        [API_ATTRIBUTE_NAMES.operation]: operation,
        [API_ATTRIBUTE_NAMES.serviceUrl]: serviceUrl,
        [API_ATTRIBUTE_NAMES.conversationId]: conversationId,
        ...activity?.type !== void 0 ? { [API_ATTRIBUTE_NAMES.activityType]: activity.type } : {},
        ...options?.activityId !== void 0 ? { [API_ATTRIBUTE_NAMES.activityId]: options.activityId } : {}
      },
      ...options?.captureResponseActivityId ? { onResponse: setResponseActivityId } : {}
    })
  };
}
function setResponseActivityId(span, res) {
  const id = getResponseActivityId(res.data);
  if (id) {
    span.setAttribute(API_ATTRIBUTE_NAMES.activityId, id);
  }
}
function getResponseActivityId(data) {
  if (!data || typeof data !== "object") {
    return void 0;
  }
  const id = data.id;
  return typeof id === "string" && id ? id : void 0;
}
class ConversationActivityClient {
  serviceUrl;
  get http() {
    return this._http;
  }
  set http(v) {
    ensureApiOutboundTelemetryMiddleware(v);
    this._http = v;
  }
  _http;
  _apiClientSettings;
  constructor(serviceUrl, options, apiClientSettings) {
    this.serviceUrl = normalizeServiceUrl(serviceUrl);
    if (!options) {
      this._http = new Client();
    } else if ("request" in options) {
      this._http = options;
    } else {
      this._http = new Client(options);
    }
    ensureApiOutboundTelemetryMiddleware(this._http);
    this._apiClientSettings = mergeApiClientSettings(apiClientSettings);
  }
  async create(conversationId, params) {
    const activity = toActivityParams(params);
    const plan = getPlanInfo(activity);
    const res = await this.http.post(
      `${this.serviceUrl}/v3/conversations/${conversationId}/activities`,
      activity,
      apiOutboundTelemetryConfig(OUTBOUND_OPERATIONS.create, this.serviceUrl, conversationId, activity, {
        captureResponseActivityId: true
      })
    );
    if (plan && plan.planType !== "complete") {
      return { id: "DO_NOT_USE_PLACEHOLDER_ID" };
    }
    return res.data;
  }
  async update(conversationId, id, params) {
    const activity = toActivityParams(params);
    const res = await this.http.put(
      `${this.serviceUrl}/v3/conversations/${conversationId}/activities/${id}`,
      activity,
      apiOutboundTelemetryConfig(OUTBOUND_OPERATIONS.update, this.serviceUrl, conversationId, activity, {
        activityId: id,
        captureResponseActivityId: true
      })
    );
    return res.data;
  }
  async reply(conversationId, id, params) {
    const activity = { ...toActivityParams(params), replyToId: id };
    const plan = getPlanInfo(activity);
    const res = await this.http.post(
      `${this.serviceUrl}/v3/conversations/${conversationId}/activities`,
      activity,
      apiOutboundTelemetryConfig(OUTBOUND_OPERATIONS.reply, this.serviceUrl, conversationId, activity, {
        captureResponseActivityId: true
      })
    );
    if (plan && plan.planType !== "complete") {
      return { id: "DO_NOT_USE_PLACEHOLDER_ID" };
    }
    return res.data;
  }
  async createReplyChain(conversationId, id, params) {
    return this.sendInReplyChain(conversationId, id, params, false);
  }
  async createTargetedReplyChain(conversationId, id, params) {
    return this.sendInReplyChain(conversationId, id, params, true);
  }
  async delete(conversationId, id) {
    const url = `${this.serviceUrl}/v3/conversations/${conversationId}/activities/${id}`;
    const res = await this.http.delete(
      url,
      apiOutboundTelemetryConfig(
        OUTBOUND_OPERATIONS.delete,
        this.serviceUrl,
        conversationId,
        void 0,
        { activityId: id }
      )
    );
    return res.data;
  }
  async getMembers(conversationId, id) {
    const url = `${this.serviceUrl}/v3/conversations/${conversationId}/activities/${id}/members`;
    const res = await this.http.get(url);
    return (res.data ?? []).map(resolveAadObjectId);
  }
  async createTargeted(conversationId, params) {
    const activity = toActivityParams(params);
    const res = await this.http.post(
      `${this.serviceUrl}/v3/conversations/${conversationId}/activities?isTargetedActivity=true`,
      activity,
      apiOutboundTelemetryConfig(OUTBOUND_OPERATIONS.createTargeted, this.serviceUrl, conversationId, activity, {
        captureResponseActivityId: true
      })
    );
    return res.data;
  }
  async updateTargeted(conversationId, id, params) {
    const activity = toActivityParams(params);
    const res = await this.http.put(
      `${this.serviceUrl}/v3/conversations/${conversationId}/activities/${id}?isTargetedActivity=true`,
      activity,
      apiOutboundTelemetryConfig(OUTBOUND_OPERATIONS.updateTargeted, this.serviceUrl, conversationId, activity, {
        activityId: id,
        captureResponseActivityId: true
      })
    );
    return res.data;
  }
  async deleteTargeted(conversationId, id) {
    const url = `${this.serviceUrl}/v3/conversations/${conversationId}/activities/${id}?isTargetedActivity=true`;
    const res = await this.http.delete(
      url,
      apiOutboundTelemetryConfig(
        OUTBOUND_OPERATIONS.deleteTargeted,
        this.serviceUrl,
        conversationId,
        void 0,
        { activityId: id }
      )
    );
    return res.data;
  }
  async sendInReplyChain(conversationId, id, params, targeted) {
    requireId("conversationId", conversationId);
    requireId("id", id);
    const activity = toActivityParams(params);
    const query = targeted ? "?isTargetedActivity=true" : "";
    const res = await this.http.post(
      `${this.serviceUrl}/v3/conversations/${encodeURIComponent(conversationId)}/replyChains/${encodeURIComponent(id)}${query}`,
      activity,
      apiOutboundTelemetryConfig(
        targeted ? OUTBOUND_OPERATIONS.createTargetedReplyChain : OUTBOUND_OPERATIONS.createReplyChain,
        this.serviceUrl,
        conversationId,
        activity,
        { captureResponseActivityId: true }
      )
    );
    return res.data;
  }
}

export { ConversationActivityClient };
//# sourceMappingURL=activity.mjs.map
//# sourceMappingURL=activity.mjs.map