12 |
13 | ## Task Router Dependencies
14 |
15 | ### Workflow
16 |
17 | Before using this plugin you must first create a dedicated TaskRouter workflow for outbound calls. You can do this [here](https://www.twilio.com/console/taskrouter/dashboard). Make sure it is part of your **Flex Task Assignment** workspace.
18 |
19 | * Ensure there is the following matching workers expression for the only filter on the workspace.
20 | * `task.targetWorker === worker.contact_uri`
21 | * Ensure the **priorty** of the filter is set to **1000** (or at least the highest in the system).
22 | * Make sure the filter matches to a queue with Everyone on it. The default Everyone queue will work but if you want to seperate real time reporting for outbound calls, you should make a dedicated queue for it with a queue expression.
23 | * `1 === 1`
24 |
25 | ### Activities
26 |
27 | This plugin forces the agent into an offline state to block calls while dialing out and an online state to accept the outbound call thats been placed. You must ensure these are agent activity states are available for this plugin to work. For both offline and available, two possible activities have been programmed, the plugin will try one of the activities and if its not available, try the other, if thats not available it will fail. You can either provision one of the states or update the code to switch to an equivalent activity that you do have configured in Task Router.
28 |
29 | Available states programmed by default (One of these must be configured in Task Router):
30 | * Available
31 | * Idle
32 |
33 | Unavailable states programmed by default (One of these must be configured in Task Router):
34 | * Outbound Calls
35 | * Offline
36 |
37 | 
38 |
39 | ## Twilio Serverless Dependency
40 |
41 | You will need the [twilio CLI](https://www.twilio.com/docs/twilio-cli/quickstart) and the [serverless plugin](https://www.twilio.com/docs/labs/serverless-toolkit/getting-started) to deploy the functions you can install with the following commands
42 |
43 | `npm install twilio-cli -g`
44 |
45 | and then
46 |
47 | `twilio plugins:install @twilio-labs/plugin-serverless`
48 |
49 | ## How To Use
50 |
51 | 1. Setup dependencies above, The workflow and the outbound calls worker activity.
52 | 2. Clone the repository.
53 | 3. Copy `./public/appConfig.example.js` to `./public/appConfig.js` and set your account sid.
54 | 4. Run `npm install`.
55 | 5. Copy `./dialpad-functions/.env.sample` to `./dialpad-functions/.env` and populate the appropriate SIDs. The workflow sid should be the workflow dependency described above.
56 | 6. CD into `./dialpad-functions/` then run `npm install` and then `twilio serverless:deploy` (optionally you can run locally with `twilio serverless:start --ngrok=""`.
57 | 7. Take note of the domain of where they deployed and update `FUNCTIONS_HOSTNAME` in [./src/OutboundDialingWithConferencePlugin.js](./blob/master/src/OutboundDialingWithConferencePlugin.js).
58 | 7. Update the `DEFAULT_FROM_NUMBER` in [./src/OutboundDialingWithConferencePlugin.js](./blob/master/src/OutboundDialingWithConferencePlugin.js) to a twilio number or a verified number associated with your account.
59 | 8. CD back to the root folder and run `npm start` to run locally or `npm run-script build` and deploy the generated `./build/plugin-outbound-dialing-with-conference.js` to [Twilio Assests](https://www.twilio.com/console/assets/public) to include plugin with hosted Flex.
60 |
61 | ## Important Notes
62 |
63 | * The plugin assumes an activity of `Outbound Calls` or `Offline` is configured for making the worker automatically unavailable, if these are not worker activity states that are available, you can either add them or update the code to change to a different state. The same is true for ensuring an available activity of `Available` or `Idle` is in the system.
64 | * This plugin is not compatible with the dialpad plugin that is listed as an `Experimental feature` - the expiremental feature or more recently, the `Pre Release` feature must be turned off.
65 | * If you place a `phone` attribute on the worker and assign it a twilio or verified number, the call will be placed from that number instead of the default number.
66 | * This solution doesnt support and is not suitable for direct agent to agent dialing.
67 | * Since the call is routed to the agent only after the call is answered, there can be a perceived delay, typically less than a second, of the agent and the customer connecting on the conference. It is adviced to configure the hold music for the outbound call to be silence, this creates a smoother experience for the person being dialed.
68 |
69 | ## TODOs
70 |
71 | 1. Improve styling to better match base palette.
72 | 2. Add in improved text box for entering numbers with country code drop down.
73 | 3. Introduce callback task for making outbound calls from a callback .
74 | 4. Update plugin builder to use serverless:cli for plugin asset deployment and align functions hostname automatically.
75 |
76 | ## Changelog
77 |
78 | v1.3 - Moved dialpad to main header to avoid the responsive rendering of the side nav unmounting when resizing the canvas.
79 |
80 | v1.2 - converted plugin to use Twilio functions and sync docs to manage state. Also merged in external transfer features.
81 |
82 | v1.1 - added ringtone when dialing, DTMF tones while on a call and better state management.
83 |
84 | - breaking change to url, must align with backend
85 |
86 | v1.0 - initial release
87 |
88 | ## Code of Conduct
89 |
90 | Please be aware that this project has a [Code of Conduct](https://github.com/twilio-labs/.github/blob/master/CODE_OF_CONDUCT.md). The tldr; is to just be excellent to each other ❤️
91 |
--------------------------------------------------------------------------------
/dialpad-functions/.env.sample:
--------------------------------------------------------------------------------
1 | ACCOUNT_SID=AC...
2 | AUTH_TOKEN=...
3 | TWILIO_WORKFLOW_SID=WW...
4 | TWILIO_WORKSPACE_SID=WS...
5 | TWILIO_SYNC_SERVICE_SID=IS...
6 | ACCOUNT_SID_X=AC...
7 | ACCOUNT_SID_Y=AC...
--------------------------------------------------------------------------------
/dialpad-functions/.nvmrc:
--------------------------------------------------------------------------------
1 | 8.10.0
--------------------------------------------------------------------------------
/dialpad-functions/functions/external-transfer/add-conference-participant.js:
--------------------------------------------------------------------------------
1 | const nodeFetch = require('node-fetch');
2 | const TokenValidator = require('twilio-flex-token-validator').functionValidator;
3 |
4 | exports.handler = TokenValidator(async function (context, event, callback) {
5 | const response = new Twilio.Response();
6 | response.appendHeader('Access-Control-Allow-Origin', '*');
7 | response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
8 | response.appendHeader('Content-Type', 'application/json');
9 | response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');
10 |
11 | console.log('add-conference-participant parameters:');
12 | Object.keys(event).forEach(key => {
13 | if (key !== "token" || key !== "Token") {
14 | console.log(`${key}: ${event[key]}`);
15 | }
16 | });
17 |
18 | if (Object.keys(event).length === 0) {
19 | console.log('Empty event object, likely an OPTIONS request');
20 | return callback(null, response);
21 | }
22 |
23 | const {
24 | taskSid,
25 | to,
26 | from
27 | } = event;
28 |
29 | console.log(`Adding ${to} to named conference ${taskSid}`);
30 | const client = context.getTwilioClient();
31 | const participantsResponse = await client
32 | .conferences(taskSid)
33 | .participants
34 | .create({
35 | to,
36 | from,
37 | earlyMedia: true,
38 | endConferenceOnExit: false
39 | });
40 | console.log('Participant response properties:');
41 | Object.keys(participantsResponse).forEach(key => {
42 | console.log(`${key}: ${participantsResponse[key]}`);
43 | });
44 | response.setBody({
45 | ...participantsResponse,
46 | status: 200,
47 | _version: undefined
48 | });
49 |
50 | return callback(null, response);
51 | });
52 |
--------------------------------------------------------------------------------
/dialpad-functions/functions/external-transfer/get-call-properties.js:
--------------------------------------------------------------------------------
1 | const nodeFetch = require('node-fetch');
2 | const TokenValidator = require('twilio-flex-token-validator').functionValidator;
3 |
4 | exports.handler = TokenValidator(async function (context, event, callback) {
5 | const response = new Twilio.Response();
6 | response.appendHeader('Access-Control-Allow-Origin', '*');
7 | response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
8 | response.appendHeader('Content-Type', 'application/json');
9 | response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');
10 |
11 | console.log('get-call-properties parameters:');
12 | Object.keys(event).forEach(key => {
13 | if (key !== "token" || key !== "Token") {
14 | console.log(`${key}: ${event[key]}`);
15 | }
16 | });
17 |
18 | if (Object.keys(event).length === 0) {
19 | console.log('Empty event object, likely an OPTIONS request');
20 | return callback(null, response);
21 | }
22 |
23 | const {
24 | callSid,
25 | } = event;
26 |
27 | console.log(`Getting properties for call SID ${callSid}`);
28 | const client = context.getTwilioClient();
29 | const callProperties = await client
30 | .calls(callSid)
31 | .fetch();
32 | console.log('Call properties:');
33 | Object.keys(callProperties).forEach(key => {
34 | console.log(`${key}: ${callProperties[key]}`);
35 | });
36 |
37 | response.setBody({
38 | ...callProperties,
39 | _version: undefined
40 | });
41 |
42 | return callback(null, response);
43 | });
44 |
--------------------------------------------------------------------------------
/dialpad-functions/functions/external-transfer/hold-conference-participant.js:
--------------------------------------------------------------------------------
1 | const nodeFetch = require('node-fetch');
2 | const TokenValidator = require('twilio-flex-token-validator').functionValidator;
3 |
4 | exports.handler = TokenValidator(async function (context, event, callback) {
5 | const response = new Twilio.Response();
6 | response.appendHeader('Access-Control-Allow-Origin', '*');
7 | response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
8 | response.appendHeader('Content-Type', 'application/json');
9 | response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');
10 |
11 | console.log('hold-conference-participant parameters:');
12 | Object.keys(event).forEach(key => {
13 | if (key !== "token" || key !== "Token") {
14 | console.log(`${key}: ${event[key]}`);
15 | }
16 | });
17 |
18 | if (Object.keys(event).length === 0) {
19 | console.log('Empty event object, likely an OPTIONS request');
20 | return callback(null, response);
21 | }
22 |
23 | const {
24 | conference,
25 | participant,
26 | hold
27 | } = event;
28 |
29 | console.log(`${hold ? 'Holding' : 'Unholding'} participant ${participant} `
30 | + `in conference ${conference}`);
31 | const client = context.getTwilioClient();
32 | const participantsResponse = await client.conferences(conference)
33 | .participants(participant)
34 | .update({
35 | hold,
36 | });
37 |
38 |
39 | response.setBody({
40 | ...participantsResponse,
41 | status: 200,
42 | _version: undefined
43 | });
44 |
45 | console.log(`Participant ${participant} updated in conference \
46 | ${conference}. Participant response properties:`);
47 |
48 | Object.keys(response.body).forEach(key => {
49 | console.log(` ${key}:`, response.body[key]);
50 | });
51 |
52 | return callback(null, response);
53 | });
54 |
--------------------------------------------------------------------------------
/dialpad-functions/functions/external-transfer/remove-conference-participant.js:
--------------------------------------------------------------------------------
1 | const nodeFetch = require('node-fetch');
2 | const TokenValidator = require('twilio-flex-token-validator').functionValidator;
3 |
4 | exports.handler = TokenValidator(async function (context, event, callback) {
5 | const response = new Twilio.Response();
6 | response.appendHeader('Access-Control-Allow-Origin', '*');
7 | response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
8 | response.appendHeader('Content-Type', 'application/json');
9 | response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');
10 |
11 | console.log('remove-conference-participant parameters:');
12 | Object.keys(event).forEach(key => {
13 | if (key !== "token" || key !== "Token") {
14 | console.log(`${key}: ${event[key]}`);
15 | }
16 | });
17 |
18 | if (Object.keys(event).length === 0) {
19 | console.log('Empty event object, likely an OPTIONS request');
20 | return callback(null, response);
21 | }
22 |
23 | const {
24 | conference,
25 | participant
26 | } = event;
27 |
28 | console.log(`Removing participant ${participant} from conference ${conference}`);
29 | const client = context.getTwilioClient();
30 | const participantResponse = await client
31 | .conferences(conference)
32 | .participants(participant)
33 | .remove();
34 | console.log('Participant response properties:');
35 | Object.keys(participantResponse).forEach(key => {
36 | console.log(`${key}: ${participantResponse[key]}`);
37 | });
38 |
39 | return callback(null, response);
40 | });
41 |
--------------------------------------------------------------------------------
/dialpad-functions/functions/external-transfer/update-conference-participant.js:
--------------------------------------------------------------------------------
1 | const nodeFetch = require('node-fetch');
2 | const TokenValidator = require('twilio-flex-token-validator').functionValidator;
3 |
4 | exports.handler = TokenValidator(async function (context, event, callback) {
5 | const response = new Twilio.Response();
6 | response.appendHeader('Access-Control-Allow-Origin', '*');
7 | response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
8 | response.appendHeader('Content-Type', 'application/json');
9 | response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');
10 |
11 | console.log('update-conference-participant parameters:');
12 | Object.keys(event).forEach(key => {
13 | if (key !== "token" || key !== "Token") {
14 | console.log(`${key}: ${event[key]}`);
15 | }
16 | });
17 |
18 | if (Object.keys(event).length === 0) {
19 | console.log('Empty event object, likely an OPTIONS request');
20 | return callback(null, response);
21 | }
22 |
23 | const {
24 | conference,
25 | participant,
26 | endConferenceOnExit
27 | } = event;
28 |
29 | console.log(`Updating participant ${participant} in conference ${conference}`);
30 | const client = context.getTwilioClient();
31 | const participantResponse = await client
32 | .conferences(conference)
33 | .participants(participant)
34 | .update({
35 | endConferenceOnExit
36 | }).catch(e => {
37 | console.error(e);
38 | return {};
39 | });
40 | console.log('Participant response properties:');
41 | Object.keys(participantResponse).forEach(key => {
42 | console.log(`${key}: ${participantResponse[key]}`);
43 | });
44 |
45 | response.setBody({
46 | status: 200
47 | });
48 |
49 | return callback(null, response);
50 | });
51 |
--------------------------------------------------------------------------------
/dialpad-functions/functions/outbound-dialing/callHandlerTwiml.protected.js:
--------------------------------------------------------------------------------
1 | exports.handler = async function (context, event, callback) {
2 |
3 | console.log("callhandler for: ", event.CallSid);
4 | console.log("worker:", event.workerContactUri);
5 | console.log("to:", event.To);
6 | console.log("workflowSid:", context.TWILIO_WORKFLOW_SID);
7 |
8 | var taskAttributes = {
9 | targetWorker: event.workerContactUri,
10 | autoAnswer: "true",
11 | type: "outbound",
12 | direction: "outbound",
13 | name: event.To
14 | };
15 |
16 | let twiml = new Twilio.twiml.VoiceResponse();
17 |
18 | var enqueue = twiml.enqueue({
19 | workflowSid: `${context.TWILIO_WORKFLOW_SID}`
20 | });
21 |
22 | enqueue.task(JSON.stringify(taskAttributes));
23 | callback(null, twiml);
24 | }
25 |
26 |
--------------------------------------------------------------------------------
/dialpad-functions/functions/outbound-dialing/callStatusUpdateHandler.protected.js:
--------------------------------------------------------------------------------
1 | /*
2 | Function for recieving call status updates and pushing them into
3 | a sync document monitored by the worker. This allows the front end
4 | to recognize when the call is queued, ringing, answered and for
5 | the front end to recieve the task
6 | */
7 |
8 | const updateSyncDoc = (context, event) => {
9 | const client = context.getTwilioClient();
10 | const syncService = client.sync.services(context.TWILIO_SYNC_SERVICE_SID);
11 |
12 | return new Promise(function (resolve, reject) {
13 | syncService.documents(event.workerSyncDoc)
14 | .update({
15 | data: {
16 | autoDial: false,
17 | call: {
18 | callSid: event.CallSid,
19 | callStatus: event.CallStatus
20 | }
21 | }
22 | })
23 | .then(() => resolve())
24 | .catch(error => {
25 | console.log("ERROR updating sync map: ", error);
26 | resolve();
27 | })
28 | })
29 | }
30 |
31 | exports.handler = async function (context, event, callback) {
32 |
33 | console.log("callback for: ", event.CallSid);
34 | console.log("status: ", event.CallStatus);
35 | console.log("workerSyncDoc: ", event.workerSyncDoc);
36 | console.log("workerSid: ", event.workerSid);
37 |
38 | const response = new Twilio.Response();
39 |
40 | response.appendHeader('Access-Control-Allow-Origin', '*');
41 | response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
42 | response.appendHeader('Content-Type', 'application/json');
43 | response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');
44 |
45 | // We dont need to know about calls that are completed as this is the natural part of the life cycle after the call has been answered
46 | if (event.CallStatus !== "completed") {
47 | updateSyncDoc(context, event).then(() => callback(null, response))
48 | } else {
49 | callback(null, response)
50 | }
51 |
52 | };
53 |
54 |
55 |
--------------------------------------------------------------------------------
/dialpad-functions/functions/outbound-dialing/callTreatment.js:
--------------------------------------------------------------------------------
1 | const nodeFetch = require('node-fetch');
2 | const TokenValidator = require('twilio-flex-token-validator').functionValidator;
3 |
4 | exports.handler = TokenValidator(async function (context, event, callback) {
5 |
6 | console.log("callTreament: callTreament event parameters");
7 | console.log("callTreament: To: ", event.To);
8 |
9 | const response = new Twilio.Response();
10 |
11 | response.appendHeader('Access-Control-Allow-Origin', '*');
12 | response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
13 | response.appendHeader('Content-Type', 'application/json');
14 | response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');
15 |
16 | // Add Environment variables to distinquish accounts
17 | if (context.ACCOUNT_SID == context.ACCOUNT_SID_Y) {
18 | //apply call treatments for this account
19 | response.setBody({ To: event.To });
20 | }
21 | else {
22 | response.setBody({ To: event.To });
23 | }
24 |
25 | callback(null, response);
26 |
27 | });
--------------------------------------------------------------------------------
/dialpad-functions/functions/outbound-dialing/endCall.js:
--------------------------------------------------------------------------------
1 | const nodeFetch = require('node-fetch');
2 | const TokenValidator = require('twilio-flex-token-validator').functionValidator;
3 |
4 | function hangupCall(context, event) {
5 |
6 | const client = context.getTwilioClient();
7 | return new Promise(function (resolve, reject) {
8 | client
9 | .calls(event.CallSid)
10 | .update({ status: "completed" })
11 | .then(call => {
12 | console.log("terminated call: ", call.sid);
13 | resolve({ call: { callStatus: call.status, callSid: call.sid }, error: null });
14 | })
15 | .catch(error => {
16 | console.log("Failed to terminate call: ", data.callSid);
17 | resolve({ call: null, error });
18 | });
19 | });
20 | }
21 |
22 | exports.handler = TokenValidator(async function (context, event, callback) {
23 |
24 | console.log("endCall for: ", event.CallSid);
25 |
26 | const response = new Twilio.Response();
27 |
28 | response.appendHeader('Access-Control-Allow-Origin', '*');
29 | response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
30 | response.appendHeader('Content-Type', 'application/json');
31 | response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');
32 |
33 | const hangupCallResult = await hangupCall(context, event)
34 | if (hangupCallResult.error) {
35 | response.setStatusCode(hangupCallResult.error.status)
36 | }
37 | response.setBody(hangupCallResult);
38 |
39 | callback(null, response);
40 |
41 | });
--------------------------------------------------------------------------------
/dialpad-functions/functions/outbound-dialing/forceUpdateSyncDoc.js:
--------------------------------------------------------------------------------
1 | const nodeFetch = require('node-fetch');
2 | const TokenValidator = require('twilio-flex-token-validator').functionValidator;
3 |
4 | const updateSyncDoc = (context, event) => {
5 |
6 | const client = context.getTwilioClient();
7 | const syncService = client.sync.services(context.TWILIO_SYNC_SERVICE_SID);
8 |
9 | return new Promise(function (resolve, reject) {
10 |
11 | client.calls(event.callSid)
12 | .fetch()
13 | .then(call => {
14 |
15 | syncService.documents(event.syncDocName)
16 | .update({
17 | data: {
18 | autoDial: false,
19 | call: {
20 | callSid: call.sid,
21 | callStatus: call.status
22 | }
23 | }
24 | })
25 | .then(() => resolve())
26 | .catch(error => {
27 | console.log("ERROR updating sync map: ", error);
28 | resolve();
29 | })
30 | })
31 | .catch(error => {
32 | console.log("Unable to retrieve call for sid:", event.callSid);
33 | resolve()
34 | })
35 | })
36 | }
37 |
38 | exports.handler = TokenValidator(async function (context, event, callback) {
39 |
40 | console.log("forceUpdateSyncDoc request parameters:");
41 | console.log("callSid:", event.callSid);
42 | console.log("syncDocName: ", event.syncDocName);
43 |
44 | const response = new Twilio.Response();
45 |
46 | response.appendHeader('Access-Control-Allow-Origin', '*');
47 | response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
48 | response.appendHeader('Content-Type', 'application/json');
49 | response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');
50 |
51 | await updateSyncDoc(context, event)
52 |
53 | callback(null, response);
54 |
55 | });
--------------------------------------------------------------------------------
/dialpad-functions/functions/outbound-dialing/invokeOutboundCall.protected.js:
--------------------------------------------------------------------------------
1 | /*
2 | Function for triggering an outbound call from a third part application
3 | */
4 | exports.handler = async function (context, event, callback) {
5 |
6 | console.log("number to dial: ", event.To);
7 | console.log("workerContactUri:", event.workerContactUri);
8 |
9 | const response = new Twilio.Response();
10 |
11 | response.appendHeader('Access-Control-Allow-Origin', '*');
12 | response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
13 | response.appendHeader('Content-Type', 'application/json');
14 | response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');
15 |
16 | const client = context.getTwilioClient();
17 | const syncService = client.sync.services(context.TWILIO_SYNC_SERVICE_SID);
18 |
19 | syncService.documents(event.workerContactUri + ".outbound-call")
20 | .update({
21 | data: {
22 | autoDial: true,
23 | numberToDial: event.To,
24 | }
25 | }).then(newDoc => {
26 | callback(null, response);
27 | })
28 | };
--------------------------------------------------------------------------------
/dialpad-functions/functions/outbound-dialing/makeCall.js:
--------------------------------------------------------------------------------
1 | const nodeFetch = require('node-fetch');
2 | const TokenValidator = require('twilio-flex-token-validator').functionValidator;
3 |
4 | async function getCallTreatment(context, event) {
5 |
6 | console.log('makeCall: Getting Call Treatment');
7 |
8 | const callTreatmentUrl = encodeURI(
9 | "https://" +
10 | event.functionsDomain +
11 | "/outbound-dialing/callTreatment?Token=" +
12 | event.Token +
13 | "&To=" +
14 | event.To
15 | );
16 |
17 | const fetchResponse = await nodeFetch(callTreatmentUrl, {
18 | method: 'POST',
19 | headers: {
20 | 'Content-Type': 'application/json',
21 | },
22 | body: JSON.stringify({
23 | To: event.To
24 | })
25 | });
26 |
27 | const callTreatmentResponse = await fetchResponse.json();
28 | console.log('makeCall: CallTreatmentResponse: ', callTreatmentResponse)
29 | return callTreatmentResponse.To;
30 |
31 | }
32 |
33 | function makeOutboundCall(context, event) {
34 | const client = context.getTwilioClient();
35 |
36 | return new Promise(async function (resolve, reject) {
37 | const callHandlerCallbackURL = encodeURI(
38 | "https://" +
39 | event.functionsDomain +
40 | "/outbound-dialing/callHandlerTwiml?workerContactUri=" +
41 | event.workerContactUri
42 | );
43 |
44 | const statusCallbackURL = encodeURI(
45 | "https://" +
46 | event.functionsDomain +
47 | "/outbound-dialing/callStatusUpdateHandler?workerSyncDoc=" +
48 | event.workerContactUri +
49 | ".outbound-call" +
50 | "&workerSid=" +
51 | event.workerSid
52 | );
53 |
54 | const to = await getCallTreatment(context, event);
55 |
56 | client.calls
57 | .create({
58 | url: callHandlerCallbackURL,
59 | to: to,
60 | from: event.From,
61 | statusCallback: statusCallbackURL,
62 | statusCallbackEvent: ["ringing", "answered", "completed"]
63 | })
64 | .then(call => {
65 | console.log("makeCall: call created: ", call.sid);
66 | resolve({ call: call, error: null });
67 | })
68 | .catch(error => {
69 | console.log("makeCall: call creation failed");
70 | resolve({ call: null, error });
71 | });
72 | });
73 | }
74 |
75 | exports.handler = TokenValidator(async function (context, event, callback) {
76 |
77 | console.log("makeCall: makeCall request parameters:");
78 | console.log("makeCall: to:", event.To);
79 | console.log("makeCall: from:", event.From);
80 | console.log("makeCall: workerContactUri:", event.workerContactUri);
81 | console.log("makeCall: callbackDomain:", event.functionsDomain);
82 | console.log("makeCall: workerSid", event.workerSid);
83 |
84 | const response = new Twilio.Response();
85 |
86 | response.appendHeader('Access-Control-Allow-Origin', '*');
87 | response.appendHeader('Access-Control-Allow-Methods', 'OPTIONS POST');
88 | response.appendHeader('Content-Type', 'application/json');
89 | response.appendHeader('Access-Control-Allow-Headers', 'Content-Type');
90 |
91 | const makeCallResult = await makeOutboundCall(context, event)
92 | if (makeCallResult.error) {
93 | response.setStatusCode(makeCallResult.error.status)
94 | }
95 | response.setBody(makeCallResult);
96 |
97 | callback(null, response);
98 |
99 | });
--------------------------------------------------------------------------------
/dialpad-functions/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "dialpad-functions",
3 | "version": "0.0.0",
4 | "private": true,
5 | "scripts": {
6 | "test": "echo \"Error: no test specified\" && exit 1",
7 | "start": "twilio-run --env"
8 | },
9 | "devDependencies": {
10 | "twilio-run": "^2.0.0"
11 | },
12 | "engines": {
13 | "node": "8.10.0"
14 | },
15 | "dependencies": {
16 | "node-fetch": "^2.6.0",
17 | "twilio-flex-token-validator": "^1.5.1"
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "plugin-outbound-dialing-with-conference",
3 | "description": "Example front end implementation of a dialpad that creates outbound calls via a voice sdk and sends call to worker via task router",
4 | "version": "1.3.0",
5 | "author": "Jared Hunter