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

<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

'use strict';

var teams_common = require('@microsoft/teams.common');
var activities = require('../../activities');
var constants = require('../../diagnostics/constants');
var models = require('../../models');
var apiClientSettings = require('../api-client-settings');
var apiOutboundMiddleware = require('../api-outbound-middleware');
var serviceUrl = require('../service-url');

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: apiOutboundMiddleware.withApiOutboundTelemetry({
      operation,
      attributes: {
        [constants.API_ATTRIBUTE_NAMES.operation]: operation,
        [constants.API_ATTRIBUTE_NAMES.serviceUrl]: serviceUrl,
        [constants.API_ATTRIBUTE_NAMES.conversationId]: conversationId,
        ...activity?.type !== void 0 ? { [constants.API_ATTRIBUTE_NAMES.activityType]: activity.type } : {},
        ...options?.activityId !== void 0 ? { [constants.API_ATTRIBUTE_NAMES.activityId]: options.activityId } : {}
      },
      ...options?.captureResponseActivityId ? { onResponse: setResponseActivityId } : {}
    })
  };
}
function setResponseActivityId(span, res) {
  const id = getResponseActivityId(res.data);
  if (id) {
    span.setAttribute(constants.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) {
    apiOutboundMiddleware.ensureApiOutboundTelemetryMiddleware(v);
    this._http = v;
  }
  _http;
  _apiClientSettings;
  constructor(serviceUrl$1, options, apiClientSettings$1) {
    this.serviceUrl = serviceUrl.normalizeServiceUrl(serviceUrl$1);
    if (!options) {
      this._http = new teams_common.Client();
    } else if ("request" in options) {
      this._http = options;
    } else {
      this._http = new teams_common.Client(options);
    }
    apiOutboundMiddleware.ensureApiOutboundTelemetryMiddleware(this._http);
    this._apiClientSettings = apiClientSettings.mergeApiClientSettings(apiClientSettings$1);
  }
  async create(conversationId, params) {
    const activity = activities.toActivityParams(params);
    const plan = models.getPlanInfo(activity);
    const res = await this.http.post(
      `${this.serviceUrl}/v3/conversations/${conversationId}/activities`,
      activity,
      apiOutboundTelemetryConfig(constants.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 = activities.toActivityParams(params);
    const res = await this.http.put(
      `${this.serviceUrl}/v3/conversations/${conversationId}/activities/${id}`,
      activity,
      apiOutboundTelemetryConfig(constants.OUTBOUND_OPERATIONS.update, this.serviceUrl, conversationId, activity, {
        activityId: id,
        captureResponseActivityId: true
      })
    );
    return res.data;
  }
  async reply(conversationId, id, params) {
    const activity = { ...activities.toActivityParams(params), replyToId: id };
    const plan = models.getPlanInfo(activity);
    const res = await this.http.post(
      `${this.serviceUrl}/v3/conversations/${conversationId}/activities`,
      activity,
      apiOutboundTelemetryConfig(constants.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(
        constants.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(models.resolveAadObjectId);
  }
  async createTargeted(conversationId, params) {
    const activity = activities.toActivityParams(params);
    const res = await this.http.post(
      `${this.serviceUrl}/v3/conversations/${conversationId}/activities?isTargetedActivity=true`,
      activity,
      apiOutboundTelemetryConfig(constants.OUTBOUND_OPERATIONS.createTargeted, this.serviceUrl, conversationId, activity, {
        captureResponseActivityId: true
      })
    );
    return res.data;
  }
  async updateTargeted(conversationId, id, params) {
    const activity = activities.toActivityParams(params);
    const res = await this.http.put(
      `${this.serviceUrl}/v3/conversations/${conversationId}/activities/${id}?isTargetedActivity=true`,
      activity,
      apiOutboundTelemetryConfig(constants.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(
        constants.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 = activities.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 ? constants.OUTBOUND_OPERATIONS.createTargetedReplyChain : constants.OUTBOUND_OPERATIONS.createReplyChain,
        this.serviceUrl,
        conversationId,
        activity,
        { captureResponseActivityId: true }
      )
    );
    return res.data;
  }
}

exports.ConversationActivityClient = ConversationActivityClient;
//# sourceMappingURL=activity.js.map
//# sourceMappingURL=activity.js.map