7013602428

Committed 28 Nov 2023 02:57AM UTC coverage: 84.629% (-0.006%) from 84.635%

Build # 7013602428

Build Type

Pull #4574

github

Committed by

web-flow

Commit Message

Merge b739f28d6 into 60824fe07

Pull Request Pull Request #4574: feat: httpRequest to add HEAD method

Run Details

9955 of 13031 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 3 new or added lines in 1 file covered. (33.33%)

4 existing lines in 1 file now uncovered.

20337 of 22763 relevant lines covered (89.34%)

7218.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.42

/libraries/botbuilder-dialogs-adaptive/src/actions/httpRequest.ts

/**
 * @module botbuilder-dialogs-adaptive
 */
/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */
import { StatusCodes } from 'botbuilder-core';
import fetch, { FetchError } from 'node-fetch';
import { Activity } from 'botbuilder';
import { BoolProperty, EnumProperty, StringProperty, UnknownProperty } from '../properties';
import { Response, Headers } from 'node-fetch';
import { evaluateExpression } from '../jsonExtensions';

import {
    BoolExpression,
    BoolExpressionConverter,
    EnumExpression,
    EnumExpressionConverter,
    StringExpression,
    StringExpressionConverter,
    ValueExpression,
    ValueExpressionConverter,
} from 'adaptive-expressions';

import {
    Converter,
    ConverterFactory,
    DialogContext,
    Dialog,
    DialogTurnResult,
    DialogConfiguration,
} from 'botbuilder-dialogs';

type HeadersInput = Record<string, string>;
type HeadersOutput = Record<string, StringExpression>;

/**
 * [HeadersInput](xref:botbuilder-dialogs-adaptive.HeadersInput) or [HeadersOutput](xref:botbuilder-dialogs-adaptive.HeadersOutput) to [HttpHeader](xref:botbuilder-dialogs-adaptive.HttpHeader) converter.
 */
class HttpHeadersConverter implements Converter<HeadersInput, HeadersOutput> {
    /**
     * Converts a [HeadersInput](xref:botbuilder-dialogs-adaptive.HeadersInput) or [HeadersOutput](xref:botbuilder-dialogs-adaptive.HeadersOutput) to [HttpHeader](xref:botbuilder-dialogs-adaptive.HttpHeader).
     *
     * @param value [HeadersInput](xref:botbuilder-dialogs-adaptive.HeadersInput) or [HeadersOutput](xref:botbuilder-dialogs-adaptive.HeadersOutput) to convert.
     * @returns The [HttpHeader](xref:botbuilder-dialogs-adaptive.HttpHeader).
     */
    convert(value: HeadersInput | HeadersOutput): HeadersOutput {
        return Object.entries(value).reduce((headers, [key, value]) => {
            return {
                ...headers,
                [key]: value instanceof StringExpression ? value : new StringExpression(value),
            };
        }, {});
    }
}

export enum ResponsesTypes {
    /**
     * No response expected
     */
    None,

    /**
     * Plain JSON response
     */
    Json,

    /**
     * JSON Activity object to send to the user
     */
    Activity,

    /**
     * Json Array of activity objects to send to the user
     */
    Activities,

    /**
     * Binary data parsing from http response content
     */
    Binary,
}

export enum HttpMethod {
    /**
     * Http GET
     */
    GET = 'GET',

    /**
     * Http POST
     */
    POST = 'POST',

    /**
     * Http PATCH
     */
    PATCH = 'PATCH',

    /**
     * Http PUT
     */
    PUT = 'PUT',

    /**
     * Http DELETE
     */
    DELETE = 'DELETE',

    /**
     * Http HEAD
     */
    HEAD = 'HEAD',
}

/**
 * Result data of HTTP operation.
 */
export class Result {
    /**
     * Initialize a new instance of Result class.
     *
     * @param headers Response headers.
     */
    constructor(headers?: Headers) {
        if (headers) {
            headers.forEach((value: string, name: string): void => {
                this.headers[name] = value;
            });
        }
    }

    /**
     * The status code from the response to HTTP operation.
     */
    statusCode?: number;

    /**
     * The reason phrase from the response to HTTP operation.
     */
    reasonPhrase?: string;

    /**
     * The headers from the response to HTTP operation.
     */
    headers?: { [key: string]: string } = {};

    /**
     * The content body from the response to HTTP operation.
     */
    content?: any;
}

export interface HttpRequestConfiguration extends DialogConfiguration {
    method?: HttpMethod;
    contentType?: StringProperty;
    url?: StringProperty;
    headers?: HeadersInput | HeadersOutput;
    body?: UnknownProperty;
    responseType?: EnumProperty<ResponsesTypes>;
    resultProperty: StringProperty;
    disabled?: BoolProperty;
}

/**
 * Action for performing an `HttpRequest`.
 */
export class HttpRequest<O extends object = {}> extends Dialog<O> implements HttpRequestConfiguration {
    static $kind = 'Microsoft.HttpRequest';

    constructor();

    /**
     * Initializes a new instance of the [HttpRequest](xref:botbuilder-dialogs-adaptive.HttpRequest) class.
     *
     * @param method The [HttpMethod](xref:botbuilder-dialogs-adaptive.HttpMethod), for example POST, GET, DELETE or PUT.
     * @param url URL for the request.
     * @param headers The headers of the request.
     * @param body The raw body of the request.
     */
    constructor(method: HttpMethod, url: string, headers: { [key: string]: string }, body: any);

    /**
     * Initializes a new instance of the [HttpRequest](xref:botbuilder-dialogs-adaptive.HttpRequest) class.
     *
     * @param method Optional. The [HttpMethod](xref:botbuilder-dialogs-adaptive.HttpMethod), for example POST, GET, DELETE or PUT.
     * @param url Optional. URL for the request.
     * @param headers Optional. The headers of the request.
     * @param body Optional. The raw body of the request.
     */
    constructor(method?: HttpMethod, url?: string, headers?: { [key: string]: string }, body?: any) {
        super();
        this.method = method || HttpMethod.GET;
        this.url = new StringExpression(url);
        if (headers) {
            this.headers = {};
            for (const key in headers) {
                this.headers[key] = new StringExpression(headers[key]);
            }
        }
        this.body = new ValueExpression(body);
    }

    /**
     * Http Method
     */
    method?: HttpMethod = HttpMethod.GET;

    /**
     * Content type of request body
     */
    contentType?: StringExpression = new StringExpression('application/json');

    /**
     * Http Url
     */
    url?: StringExpression;

    /**
     * Http Headers
     */
    headers?: { [key: string]: StringExpression } = {};
    /**
     * Http Body
     */
    body?: ValueExpression;

    /**
     * The response type of the response
     */
    responseType?: EnumExpression<ResponsesTypes> = new EnumExpression<ResponsesTypes>(ResponsesTypes.Json);

    /**
     * Gets or sets the property expression to store the HTTP response in.
     */
    resultProperty: StringExpression = new StringExpression('turn.results');

    /**
     * An optional expression which if is true will disable this action.
     */
    disabled?: BoolExpression;

    /**
     * @param property The key of the conditional selector configuration.
     * @returns The converter for the selector configuration.
     */
    getConverter(property: keyof HttpRequestConfiguration): Converter | ConverterFactory {
        switch (property) {
            case 'contentType':
                return new StringExpressionConverter();
            case 'url':
                return new StringExpressionConverter();
            case 'headers':
                return new HttpHeadersConverter();
            case 'body':
                return new ValueExpressionConverter();
            case 'responseType':
                return new EnumExpressionConverter<ResponsesTypes>(ResponsesTypes);
            case 'resultProperty':
                return new StringExpressionConverter();
            case 'disabled':
                return new BoolExpressionConverter();
            default:
                return super.getConverter(property);
        }
    }

    /**
     * Starts a new [Dialog](xref:botbuilder-dialogs.Dialog) and pushes it onto the dialog stack.
     *
     * @param dc The [DialogContext](xref:botbuilder-dialogs.DialogContext) for the current turn of conversation.
     * @param _options Optional. Initial information to pass to the dialog.
     * @returns A `Promise` representing the asynchronous operation.
     */
    async beginDialog(dc: DialogContext, _options?: O): Promise<DialogTurnResult> {
        if (this.disabled && this.disabled.getValue(dc.state)) {
            return await dc.endDialog();
        }

        const instanceUrl = this.url.getValue(dc.state);
        const instanceMethod = this.method.toString();

        const instanceHeaders = {};
        for (let key in this.headers) {
            if (key.toLowerCase() === 'content-type') {
                key = 'Content-Type';
            }
            instanceHeaders[key] = this.headers[key].getValue(dc.state);
        }
        const contentType = this.contentType.getValue(dc.state) || 'application/json';
        instanceHeaders['Content-Type'] = contentType;

        let instanceBody: string;
        let traceInfo;
        try {
            const body = evaluateExpression(dc.state, this.body);
            if (body) {
                if (typeof body === 'string') {
                    instanceBody = body;
                } else {
                    instanceBody = JSON.stringify(Object.assign({}, body));
                }
            }

            traceInfo = {
                request: {
                    method: instanceMethod,
                    url: instanceUrl,
                    headers: instanceHeaders,
                    content: instanceBody,
                },
                response: undefined,
            };

            let response: Response;

            switch (this.method) {
                case HttpMethod.DELETE:
                case HttpMethod.GET:
                    response = await fetch(instanceUrl, {
                        method: instanceMethod,
                        headers: instanceHeaders,
                    });
                    break;
                case HttpMethod.HEAD:
                    response = await fetch(instanceUrl, {
                        method: instanceMethod,
                        headers: instanceHeaders,
                    });
                    break;
                case HttpMethod.PUT:
                case HttpMethod.PATCH:
                case HttpMethod.POST:
                    response = await fetch(instanceUrl, {
                        method: instanceMethod,
                        headers: instanceHeaders,
                        body: instanceBody,
                    });
                    break;
            }

            const result = new Result(response.headers);
            result.statusCode = response.status;
            result.reasonPhrase = response.statusText;

            switch (this.responseType.getValue(dc.state)) {
                case ResponsesTypes.Activity:
                    result.content = await response.json();
                    dc.context.sendActivity(result.content as Activity);
                    break;
                case ResponsesTypes.Activities:
                    result.content = await response.json();
                    dc.context.sendActivities(result.content as Activity[]);
                    break;
                case ResponsesTypes.Json: {
                    const content = await response.text();
                    try {
                        result.content = JSON.parse(content);
                    } catch {
                        result.content = content;
                    }
                    break;
                }
                case ResponsesTypes.Binary: {
                    const buffer = await response.arrayBuffer();
                    result.content = new Uint8Array(buffer);
                    break;
                }
                case ResponsesTypes.None:
                default:
                    break;
            }

            return await this.endDialogWithResult(dc, result, traceInfo);
        } catch (err) {
            if (err instanceof FetchError) {
                const result = new Result();
                result.content = err.message;
                result.statusCode = StatusCodes.NOT_FOUND;
                return await this.endDialogWithResult(dc, result, traceInfo);
            } else {
                throw err;
            }
        }
    }

    /**
     * Writes Trace Activity for the http request and response values and returns the actionResult as the result of this operation.
     *
     * @param dc The [DialogContext](xref:botbuilder-dialogs.DialogContext) for the current turn of conversation.
     * @param result Value returned from the dialog that was called. The type
     * of the value returned is dependent on the child dialog.
     * @param traceInfo Trace information to be written.
     * @returns A `Promise` representing the asynchronous operation.
     */
    private async endDialogWithResult(dc: DialogContext, result: Result, traceInfo: any): Promise<DialogTurnResult> {
        traceInfo.response = result;

        // Write trace activity for http request and response values.
        await dc.context.sendTraceActivity('HttpRequest', traceInfo, 'Microsoft.HttpRequest', this.id);

        if (this.resultProperty) {
            dc.state.setValue(this.resultProperty.getValue(dc.state), result);
        }

        return await dc.endDialog(result);
    }

    /**
     * @protected
     * Builds the compute Id for the [Dialog](xref:botbuilder-dialogs.Dialog).
     * @returns A `string` representing the compute Id.
     */
    protected onComputeId(): string {
        return `HttpRequest[${this.method} ${this.url}]`;
    }
}

1	/**
2	* @module botbuilder-dialogs-adaptive
3	*/
4	/**
5	* Copyright (c) Microsoft Corporation. All rights reserved.
6	* Licensed under the MIT License.
7	*/
8	import { StatusCodes } from 'botbuilder-core';	2✔
9	import fetch, { FetchError } from 'node-fetch';	2✔
10	import { Activity } from 'botbuilder';
11	import { BoolProperty, EnumProperty, StringProperty, UnknownProperty } from '../properties';
12	import { Response, Headers } from 'node-fetch';
13	import { evaluateExpression } from '../jsonExtensions';	2✔
14
15	import {	2✔
16	BoolExpression,
17	BoolExpressionConverter,
18	EnumExpression,
19	EnumExpressionConverter,
20	StringExpression,
21	StringExpressionConverter,
22	ValueExpression,
23	ValueExpressionConverter,
24	} from 'adaptive-expressions';
25
26	import {	2✔
27	Converter,
28	ConverterFactory,
29	DialogContext,
30	Dialog,
31	DialogTurnResult,
32	DialogConfiguration,
33	} from 'botbuilder-dialogs';
34
35	type HeadersInput = Record<string, string>;
36	type HeadersOutput = Record<string, StringExpression>;
37
38	/**
39	* [HeadersInput](xref:botbuilder-dialogs-adaptive.HeadersInput) or [HeadersOutput](xref:botbuilder-dialogs-adaptive.HeadersOutput) to [HttpHeader](xref:botbuilder-dialogs-adaptive.HttpHeader) converter.
40	*/
41	class HttpHeadersConverter implements Converter<HeadersInput, HeadersOutput> {
42	/**
43	* Converts a [HeadersInput](xref:botbuilder-dialogs-adaptive.HeadersInput) or [HeadersOutput](xref:botbuilder-dialogs-adaptive.HeadersOutput) to [HttpHeader](xref:botbuilder-dialogs-adaptive.HttpHeader).
44	*
45	* @param value [HeadersInput](xref:botbuilder-dialogs-adaptive.HeadersInput) or [HeadersOutput](xref:botbuilder-dialogs-adaptive.HeadersOutput) to convert.
46	* @returns The [HttpHeader](xref:botbuilder-dialogs-adaptive.HttpHeader).
47	*/
48	convert(value: HeadersInput \| HeadersOutput): HeadersOutput {
49	return Object.entries(value).reduce((headers, [key, value]) => {	4✔
50	return {	8✔
51	...headers,
52	[key]: value instanceof StringExpression ? value : new StringExpression(value),	8!
53	};
54	}, {});
55	}
56	}
57
58	export enum ResponsesTypes {	2✔
59	/**
60	* No response expected
61	*/
62	None,	2✔
63
64	/**
65	* Plain JSON response
66	*/
67	Json,	2✔
68
69	/**
70	* JSON Activity object to send to the user
71	*/
72	Activity,	2✔
73
74	/**
75	* Json Array of activity objects to send to the user
76	*/
77	Activities,	2✔
78
79	/**
80	* Binary data parsing from http response content
81	*/
82	Binary,	2✔
83	}
84
85	export enum HttpMethod {	2✔
86	/**
87	* Http GET
88	*/
89	GET = 'GET',	2✔
90
91	/**
92	* Http POST
93	*/
94	POST = 'POST',	2✔
95
96	/**
97	* Http PATCH
98	*/
99	PATCH = 'PATCH',	2✔
100
101	/**
102	* Http PUT
103	*/
104	PUT = 'PUT',	2✔
105
106	/**
107	* Http DELETE
108	*/
109	DELETE = 'DELETE',	2✔
110
111	/**
112	* Http HEAD
113	*/
114	HEAD = 'HEAD',	2✔
115	}
116
117	/**
118	* Result data of HTTP operation.
119	*/
120	export class Result {	2✔
121	/**
122	* Initialize a new instance of Result class.
123	*
124	* @param headers Response headers.
125	*/
126	constructor(headers?: Headers) {
127	if (headers) {	44✔
128	headers.forEach((value: string, name: string): void => {	42✔
129	this.headers[name] = value;	40✔
130	});
131	}
132	}
133
134	/**
135	* The status code from the response to HTTP operation.
136	*/
137	statusCode?: number;
138
139	/**
140	* The reason phrase from the response to HTTP operation.
141	*/
142	reasonPhrase?: string;
143
144	/**
145	* The headers from the response to HTTP operation.
146	*/
147	headers?: { [key: string]: string } = {};	44✔
148
149	/**
150	* The content body from the response to HTTP operation.
151	*/
152	content?: any;
153	}
154
155	export interface HttpRequestConfiguration extends DialogConfiguration {
156	method?: HttpMethod;
157	contentType?: StringProperty;
158	url?: StringProperty;
159	headers?: HeadersInput \| HeadersOutput;
160	body?: UnknownProperty;
161	responseType?: EnumProperty<ResponsesTypes>;
162	resultProperty: StringProperty;
163	disabled?: BoolProperty;
164	}
165
166	/**
167	* Action for performing an `HttpRequest`.
168	*/
169	export class HttpRequest<O extends object = {}> extends Dialog<O> implements HttpRequestConfiguration {	2✔
170	static $kind = 'Microsoft.HttpRequest';	2✔
171
172	constructor();
173
174	/**
175	* Initializes a new instance of the [HttpRequest](xref:botbuilder-dialogs-adaptive.HttpRequest) class.
176	*
177	* @param method The [HttpMethod](xref:botbuilder-dialogs-adaptive.HttpMethod), for example POST, GET, DELETE or PUT.
178	* @param url URL for the request.
179	* @param headers The headers of the request.
180	* @param body The raw body of the request.
181	*/
182	constructor(method: HttpMethod, url: string, headers: { [key: string]: string }, body: any);
183
184	/**
185	* Initializes a new instance of the [HttpRequest](xref:botbuilder-dialogs-adaptive.HttpRequest) class.
186	*
187	* @param method Optional. The [HttpMethod](xref:botbuilder-dialogs-adaptive.HttpMethod), for example POST, GET, DELETE or PUT.
188	* @param url Optional. URL for the request.
189	* @param headers Optional. The headers of the request.
190	* @param body Optional. The raw body of the request.
191	*/
192	constructor(method?: HttpMethod, url?: string, headers?: { [key: string]: string }, body?: any) {
193	super();	44✔
194	this.method = method \|\| HttpMethod.GET;	44✔
195	this.url = new StringExpression(url);	44✔
196	if (headers) {	44!
197	this.headers = {};	×
198	for (const key in headers) {	×
199	this.headers[key] = new StringExpression(headers[key]);	×
200	}
201	}
202	this.body = new ValueExpression(body);	44✔
203	}
204
205	/**
206	* Http Method
207	*/
208	method?: HttpMethod = HttpMethod.GET;	44✔
209
210	/**
211	* Content type of request body
212	*/
213	contentType?: StringExpression = new StringExpression('application/json');	44✔
214
215	/**
216	* Http Url
217	*/
218	url?: StringExpression;
219
220	/**
221	* Http Headers
222	*/
223	headers?: { [key: string]: StringExpression } = {};	44✔
224	/**
225	* Http Body
226	*/
227	body?: ValueExpression;
228
229	/**
230	* The response type of the response
231	*/
232	responseType?: EnumExpression<ResponsesTypes> = new EnumExpression<ResponsesTypes>(ResponsesTypes.Json);	44✔
233
234	/**
235	* Gets or sets the property expression to store the HTTP response in.
236	*/
237	resultProperty: StringExpression = new StringExpression('turn.results');	44✔
238
239	/**
240	* An optional expression which if is true will disable this action.
241	*/
242	disabled?: BoolExpression;
243
244	/**
245	* @param property The key of the conditional selector configuration.
246	* @returns The converter for the selector configuration.
247	*/
248	getConverter(property: keyof HttpRequestConfiguration): Converter \| ConverterFactory {
249	switch (property) {	222✔
250	case 'contentType':	222!
251	return new StringExpressionConverter();	12✔
252	case 'url':
253	return new StringExpressionConverter();	44✔
254	case 'headers':
255	return new HttpHeadersConverter();	4✔
256	case 'body':
257	return new ValueExpressionConverter();	14✔
258	case 'responseType':
259	return new EnumExpressionConverter<ResponsesTypes>(ResponsesTypes);	32✔
260	case 'resultProperty':
261	return new StringExpressionConverter();	28✔
262	case 'disabled':
263	return new BoolExpressionConverter();	×
264	default:
265	return super.getConverter(property);	88✔
266	}
267	}
268
269	/**
270	* Starts a new [Dialog](xref:botbuilder-dialogs.Dialog) and pushes it onto the dialog stack.
271	*
272	* @param dc The [DialogContext](xref:botbuilder-dialogs.DialogContext) for the current turn of conversation.
273	* @param _options Optional. Initial information to pass to the dialog.
274	* @returns A `Promise` representing the asynchronous operation.
275	*/
276	async beginDialog(dc: DialogContext, _options?: O): Promise<DialogTurnResult> {
277	if (this.disabled && this.disabled.getValue(dc.state)) {	44!
278	return await dc.endDialog();	×
279	}
280
281	const instanceUrl = this.url.getValue(dc.state);	44✔
282	const instanceMethod = this.method.toString();	44✔
283
284	const instanceHeaders = {};	44✔
285	for (let key in this.headers) {	44✔
286	if (key.toLowerCase() === 'content-type') {	8!
287	key = 'Content-Type';	×
288	}
289	instanceHeaders[key] = this.headers[key].getValue(dc.state);	8✔
290	}
291	const contentType = this.contentType.getValue(dc.state) \|\| 'application/json';	44!
292	instanceHeaders['Content-Type'] = contentType;	44✔
293
294	let instanceBody: string;
295	let traceInfo;
296	try {	44✔
297	const body = evaluateExpression(dc.state, this.body);	44✔
298	if (body) {	44✔
299	if (typeof body === 'string') {	14✔
300	instanceBody = body;	8✔
301	} else {
302	instanceBody = JSON.stringify(Object.assign({}, body));	6✔
303	}
304	}
305
306	traceInfo = {	44✔
307	request: {
308	method: instanceMethod,
309	url: instanceUrl,
310	headers: instanceHeaders,
311	content: instanceBody,
312	},
313	response: undefined,
314	};
315
316	let response: Response;
317
318	switch (this.method) {	44✔
319	case HttpMethod.DELETE:	48!
320	case HttpMethod.GET:
321	response = await fetch(instanceUrl, {	24✔
322	method: instanceMethod,
323	headers: instanceHeaders,
324	});
325	break;	24✔
326	case HttpMethod.HEAD:
NEW UNCOV 327	response = await fetch(instanceUrl, {	×
328	method: instanceMethod,
329	headers: instanceHeaders,
330	});
NEW UNCOV 331	break;	×
332	case HttpMethod.PUT:
333	case HttpMethod.PATCH:
334	case HttpMethod.POST:
335	response = await fetch(instanceUrl, {	20✔
336	method: instanceMethod,
337	headers: instanceHeaders,
338	body: instanceBody,
339	});
340	break;	18✔
341	}
342
343	const result = new Result(response.headers);	42✔
344	result.statusCode = response.status;	42✔
345	result.reasonPhrase = response.statusText;	42✔
346
347	switch (this.responseType.getValue(dc.state)) {	42✔
348	case ResponsesTypes.Activity:	42!
349	result.content = await response.json();	2✔
350	dc.context.sendActivity(result.content as Activity);	2✔
351	break;	2✔
352	case ResponsesTypes.Activities:
353	result.content = await response.json();	2✔
354	dc.context.sendActivities(result.content as Activity[]);	2✔
355	break;	2✔
356	case ResponsesTypes.Json: {
357	const content = await response.text();	36✔
358	try {	36✔
359	result.content = JSON.parse(content);	36✔
360	} catch {
361	result.content = content;	24✔
362	}
363	break;	36✔
364	}
365	case ResponsesTypes.Binary: {
366	const buffer = await response.arrayBuffer();	2✔
367	result.content = new Uint8Array(buffer);	2✔
368	break;	2✔
369	}
370	case ResponsesTypes.None:
371	default:
UNCOV 372	break;	×
373	}
374
375	return await this.endDialogWithResult(dc, result, traceInfo);	42✔
376	} catch (err) {
377	if (err instanceof FetchError) {	2!
378	const result = new Result();	2✔
379	result.content = err.message;	2✔
380	result.statusCode = StatusCodes.NOT_FOUND;	2✔
381	return await this.endDialogWithResult(dc, result, traceInfo);	2✔
382	} else {
UNCOV 383	throw err;	×
384	}
385	}
386	}
387
388	/**
389	* Writes Trace Activity for the http request and response values and returns the actionResult as the result of this operation.
390	*
391	* @param dc The [DialogContext](xref:botbuilder-dialogs.DialogContext) for the current turn of conversation.
392	* @param result Value returned from the dialog that was called. The type
393	* of the value returned is dependent on the child dialog.
394	* @param traceInfo Trace information to be written.
395	* @returns A `Promise` representing the asynchronous operation.
396	*/
397	private async endDialogWithResult(dc: DialogContext, result: Result, traceInfo: any): Promise<DialogTurnResult> {
398	traceInfo.response = result;	44✔
399
400	// Write trace activity for http request and response values.
401	await dc.context.sendTraceActivity('HttpRequest', traceInfo, 'Microsoft.HttpRequest', this.id);	44✔
402
403	if (this.resultProperty) {	44!
404	dc.state.setValue(this.resultProperty.getValue(dc.state), result);	44✔
405	}
406
407	return await dc.endDialog(result);	44✔
408	}
409
410	/**
411	* @protected
412	* Builds the compute Id for the [Dialog](xref:botbuilder-dialogs.Dialog).
413	* @returns A `string` representing the compute Id.
414	*/
415	protected onComputeId(): string {
416	return `HttpRequest[${this.method} ${this.url}]`;	44✔
417	}
418	}

microsoft / botbuilder-js / 7013602428

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous