@app-connect/core 0.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +266 -0
- package/adapter/mock.js +77 -0
- package/adapter/registry.js +115 -0
- package/handlers/admin.js +60 -0
- package/handlers/auth.js +156 -0
- package/handlers/contact.js +275 -0
- package/handlers/disposition.js +194 -0
- package/handlers/log.js +586 -0
- package/handlers/user.js +102 -0
- package/index.js +1202 -0
- package/lib/analytics.js +53 -0
- package/lib/callLogComposer.js +452 -0
- package/lib/encode.js +30 -0
- package/lib/generalErrorMessage.js +42 -0
- package/lib/jwt.js +16 -0
- package/lib/oauth.js +85 -0
- package/lib/util.js +40 -0
- package/models/adminConfigModel.js +17 -0
- package/models/cacheModel.js +23 -0
- package/models/callLogModel.js +27 -0
- package/models/dynamo/lockSchema.js +25 -0
- package/models/messageLogModel.js +25 -0
- package/models/sequelize.js +17 -0
- package/models/userModel.js +38 -0
- package/package.json +58 -0
- package/releaseNotes.json +578 -0
|
@@ -0,0 +1,275 @@
|
|
|
1
|
+
const oauth = require('../lib/oauth');
|
|
2
|
+
const { UserModel } = require('../models/userModel');
|
|
3
|
+
const errorMessage = require('../lib/generalErrorMessage');
|
|
4
|
+
const adapterRegistry = require('../adapter/registry');
|
|
5
|
+
async function findContact({ platform, userId, phoneNumber, overridingFormat, isExtension }) {
|
|
6
|
+
try {
|
|
7
|
+
let user = await UserModel.findOne({
|
|
8
|
+
where: {
|
|
9
|
+
id: userId,
|
|
10
|
+
platform
|
|
11
|
+
}
|
|
12
|
+
});
|
|
13
|
+
if (!user || !user.accessToken) {
|
|
14
|
+
return {
|
|
15
|
+
successful: false,
|
|
16
|
+
returnMessage: {
|
|
17
|
+
message: `Contact not found`,
|
|
18
|
+
messageType: 'warning',
|
|
19
|
+
ttl: 5000
|
|
20
|
+
}
|
|
21
|
+
};
|
|
22
|
+
}
|
|
23
|
+
const platformModule = adapterRegistry.getAdapter(platform);
|
|
24
|
+
const authType = platformModule.getAuthType();
|
|
25
|
+
let authHeader = '';
|
|
26
|
+
switch (authType) {
|
|
27
|
+
case 'oauth':
|
|
28
|
+
const oauthApp = oauth.getOAuthApp((await platformModule.getOauthInfo({ tokenUrl: user?.platformAdditionalInfo?.tokenUrl, hostname: user?.hostname })));
|
|
29
|
+
user = await oauth.checkAndRefreshAccessToken(oauthApp, user);
|
|
30
|
+
authHeader = `Bearer ${user.accessToken}`;
|
|
31
|
+
break;
|
|
32
|
+
case 'apiKey':
|
|
33
|
+
const basicAuth = platformModule.getBasicAuth({ apiKey: user.accessToken });
|
|
34
|
+
authHeader = `Basic ${basicAuth}`;
|
|
35
|
+
break;
|
|
36
|
+
}
|
|
37
|
+
const { successful, matchedContactInfo, returnMessage, extraDataTracking } = await platformModule.findContact({ user, authHeader, phoneNumber, overridingFormat, isExtension });
|
|
38
|
+
if (matchedContactInfo != null && matchedContactInfo?.filter(c => !c.isNewContact)?.length > 0) {
|
|
39
|
+
return { successful, returnMessage, contact: matchedContactInfo, extraDataTracking };
|
|
40
|
+
}
|
|
41
|
+
else {
|
|
42
|
+
if (returnMessage) {
|
|
43
|
+
return {
|
|
44
|
+
successful,
|
|
45
|
+
returnMessage,
|
|
46
|
+
extraDataTracking,
|
|
47
|
+
contact: matchedContactInfo,
|
|
48
|
+
}
|
|
49
|
+
}
|
|
50
|
+
return {
|
|
51
|
+
successful,
|
|
52
|
+
returnMessage:
|
|
53
|
+
{
|
|
54
|
+
message: `Contact not found`,
|
|
55
|
+
messageType: 'warning',
|
|
56
|
+
details: [{
|
|
57
|
+
title: 'Details',
|
|
58
|
+
items: [
|
|
59
|
+
{
|
|
60
|
+
id: '1',
|
|
61
|
+
type: 'text',
|
|
62
|
+
text: `A contact with the phone number ${phoneNumber} could not be found in your ${platform} account.`
|
|
63
|
+
}
|
|
64
|
+
]
|
|
65
|
+
}],
|
|
66
|
+
ttl: 5000
|
|
67
|
+
},
|
|
68
|
+
contact: matchedContactInfo,
|
|
69
|
+
extraDataTracking
|
|
70
|
+
};
|
|
71
|
+
}
|
|
72
|
+
} catch (e) {
|
|
73
|
+
console.error(`platform: ${platform} \n${e.stack} \n${JSON.stringify(e.response?.data)}`);
|
|
74
|
+
if (e.response?.status === 429) {
|
|
75
|
+
return {
|
|
76
|
+
successful: false,
|
|
77
|
+
returnMessage: errorMessage.rateLimitErrorMessage({ platform }),
|
|
78
|
+
extraDataTracking: {
|
|
79
|
+
statusCode: e.response?.status,
|
|
80
|
+
}
|
|
81
|
+
};
|
|
82
|
+
}
|
|
83
|
+
else if (e.response?.status >= 400 && e.response?.status < 410) {
|
|
84
|
+
return {
|
|
85
|
+
successful: false,
|
|
86
|
+
returnMessage: errorMessage.authorizationErrorMessage({ platform }),
|
|
87
|
+
extraDataTracking: {
|
|
88
|
+
statusCode: e.response?.status,
|
|
89
|
+
}
|
|
90
|
+
};
|
|
91
|
+
}
|
|
92
|
+
return {
|
|
93
|
+
successful: false,
|
|
94
|
+
returnMessage:
|
|
95
|
+
{
|
|
96
|
+
message: `Error finding contacts`,
|
|
97
|
+
messageType: 'warning',
|
|
98
|
+
details: [
|
|
99
|
+
{
|
|
100
|
+
title: 'Details',
|
|
101
|
+
items: [
|
|
102
|
+
{
|
|
103
|
+
id: '1',
|
|
104
|
+
type: 'text',
|
|
105
|
+
text: `Please check if your account has permission to VIEW and LIST contacts`
|
|
106
|
+
}
|
|
107
|
+
]
|
|
108
|
+
}
|
|
109
|
+
],
|
|
110
|
+
ttl: 5000
|
|
111
|
+
},
|
|
112
|
+
extraDataTracking: {
|
|
113
|
+
statusCode: e.response?.status,
|
|
114
|
+
}
|
|
115
|
+
};
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
async function createContact({ platform, userId, phoneNumber, newContactName, newContactType, additionalSubmission }) {
|
|
120
|
+
try {
|
|
121
|
+
let user = await UserModel.findOne({
|
|
122
|
+
where: {
|
|
123
|
+
id: userId,
|
|
124
|
+
platform
|
|
125
|
+
}
|
|
126
|
+
});
|
|
127
|
+
if (!user || !user.accessToken) {
|
|
128
|
+
return { successful: false, message: `Contact not found` };
|
|
129
|
+
}
|
|
130
|
+
const platformModule = adapterRegistry.getAdapter(platform);
|
|
131
|
+
const authType = platformModule.getAuthType();
|
|
132
|
+
let authHeader = '';
|
|
133
|
+
switch (authType) {
|
|
134
|
+
case 'oauth':
|
|
135
|
+
const oauthApp = oauth.getOAuthApp((await platformModule.getOauthInfo({ tokenUrl: user?.platformAdditionalInfo?.tokenUrl, hostname: user?.hostname })));
|
|
136
|
+
user = await oauth.checkAndRefreshAccessToken(oauthApp, user);
|
|
137
|
+
authHeader = `Bearer ${user.accessToken}`;
|
|
138
|
+
break;
|
|
139
|
+
case 'apiKey':
|
|
140
|
+
const basicAuth = platformModule.getBasicAuth({ apiKey: user.accessToken });
|
|
141
|
+
authHeader = `Basic ${basicAuth}`;
|
|
142
|
+
break;
|
|
143
|
+
}
|
|
144
|
+
const { contactInfo, returnMessage, extraDataTracking } = await platformModule.createContact({ user, authHeader, phoneNumber, newContactName, newContactType, additionalSubmission });
|
|
145
|
+
if (contactInfo != null) {
|
|
146
|
+
return { successful: true, returnMessage, contact: contactInfo, extraDataTracking };
|
|
147
|
+
}
|
|
148
|
+
else {
|
|
149
|
+
return { successful: false, returnMessage };
|
|
150
|
+
}
|
|
151
|
+
} catch (e) {
|
|
152
|
+
console.log(`platform: ${platform} \n${e.stack}`);
|
|
153
|
+
if (e.response?.status === 429) {
|
|
154
|
+
return {
|
|
155
|
+
successful: false,
|
|
156
|
+
returnMessage: errorMessage.rateLimitErrorMessage({ platform }),
|
|
157
|
+
};
|
|
158
|
+
}
|
|
159
|
+
else if (e.response?.status >= 400 && e.response?.status < 410) {
|
|
160
|
+
return {
|
|
161
|
+
successful: false,
|
|
162
|
+
returnMessage: errorMessage.authorizationErrorMessage({ platform }),
|
|
163
|
+
extraDataTracking: {
|
|
164
|
+
statusCode: e.response?.status,
|
|
165
|
+
}
|
|
166
|
+
};
|
|
167
|
+
}
|
|
168
|
+
return {
|
|
169
|
+
successful: false,
|
|
170
|
+
returnMessage:
|
|
171
|
+
{
|
|
172
|
+
message: `Error creating contact`,
|
|
173
|
+
messageType: 'warning',
|
|
174
|
+
details: [
|
|
175
|
+
{
|
|
176
|
+
title: 'Details',
|
|
177
|
+
items: [
|
|
178
|
+
{
|
|
179
|
+
id: '1',
|
|
180
|
+
type: 'text',
|
|
181
|
+
text: `A contact with the phone number ${phoneNumber} could not be created. Make sure you have permission to create contacts in ${platform}.`
|
|
182
|
+
}
|
|
183
|
+
]
|
|
184
|
+
}
|
|
185
|
+
],
|
|
186
|
+
ttl: 5000
|
|
187
|
+
}
|
|
188
|
+
};
|
|
189
|
+
}
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
async function findContactWithName({ platform, userId, name }) {
|
|
193
|
+
try {
|
|
194
|
+
let user = await UserModel.findOne({
|
|
195
|
+
where: {
|
|
196
|
+
id: userId,
|
|
197
|
+
platform
|
|
198
|
+
}
|
|
199
|
+
});
|
|
200
|
+
if (!user || !user.accessToken) {
|
|
201
|
+
return {
|
|
202
|
+
successful: false,
|
|
203
|
+
returnMessage: {
|
|
204
|
+
message: `No contact found with name ${name}`,
|
|
205
|
+
messageType: 'warning',
|
|
206
|
+
ttl: 5000
|
|
207
|
+
}
|
|
208
|
+
};
|
|
209
|
+
}
|
|
210
|
+
const platformModule = adapterRegistry.getAdapter(platform);
|
|
211
|
+
const authType = platformModule.getAuthType();
|
|
212
|
+
let authHeader = '';
|
|
213
|
+
switch (authType) {
|
|
214
|
+
case 'oauth':
|
|
215
|
+
const oauthApp = oauth.getOAuthApp((await platformModule.getOauthInfo({ tokenUrl: user?.platformAdditionalInfo?.tokenUrl, hostname: user?.hostname })));
|
|
216
|
+
user = await oauth.checkAndRefreshAccessToken(oauthApp, user);
|
|
217
|
+
authHeader = `Bearer ${user.accessToken}`;
|
|
218
|
+
break;
|
|
219
|
+
case 'apiKey':
|
|
220
|
+
const basicAuth = platformModule.getBasicAuth({ apiKey: user.accessToken });
|
|
221
|
+
authHeader = `Basic ${basicAuth}`;
|
|
222
|
+
break;
|
|
223
|
+
}
|
|
224
|
+
const { successful, matchedContactInfo, returnMessage } = await platformModule.findContactWithName({ user, authHeader, name });
|
|
225
|
+
if (matchedContactInfo != null && matchedContactInfo?.filter(c => !c.isNewContact)?.length > 0) {
|
|
226
|
+
return { successful, returnMessage, contact: matchedContactInfo };
|
|
227
|
+
}
|
|
228
|
+
else {
|
|
229
|
+
if (returnMessage) {
|
|
230
|
+
return {
|
|
231
|
+
successful,
|
|
232
|
+
returnMessage,
|
|
233
|
+
contact: matchedContactInfo,
|
|
234
|
+
}
|
|
235
|
+
}
|
|
236
|
+
return {
|
|
237
|
+
successful,
|
|
238
|
+
returnMessage:
|
|
239
|
+
{
|
|
240
|
+
message: `No contact found with name ${name} `,
|
|
241
|
+
messageType: 'warning',
|
|
242
|
+
ttl: 5000
|
|
243
|
+
},
|
|
244
|
+
contact: matchedContactInfo
|
|
245
|
+
};
|
|
246
|
+
}
|
|
247
|
+
} catch (e) {
|
|
248
|
+
console.error(`platform: ${platform} \n${e.stack} \n${JSON.stringify(e.response?.data)}`);
|
|
249
|
+
if (e.response?.status === 429) {
|
|
250
|
+
return {
|
|
251
|
+
successful: false,
|
|
252
|
+
returnMessage: errorMessage.rateLimitErrorMessage({ platform })
|
|
253
|
+
};
|
|
254
|
+
}
|
|
255
|
+
else if (e.response?.status >= 400 && e.response?.status < 410) {
|
|
256
|
+
return {
|
|
257
|
+
successful: false,
|
|
258
|
+
returnMessage: errorMessage.authorizationErrorMessage({ platform }),
|
|
259
|
+
};
|
|
260
|
+
}
|
|
261
|
+
return {
|
|
262
|
+
successful: false,
|
|
263
|
+
returnMessage:
|
|
264
|
+
{
|
|
265
|
+
message: `Error finding contacts`,
|
|
266
|
+
messageType: 'warning',
|
|
267
|
+
ttl: 5000
|
|
268
|
+
}
|
|
269
|
+
};
|
|
270
|
+
}
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
exports.findContact = findContact;
|
|
274
|
+
exports.createContact = createContact;
|
|
275
|
+
exports.findContactWithName = findContactWithName;
|
|
@@ -0,0 +1,194 @@
|
|
|
1
|
+
// const Op = require('sequelize').Op;
|
|
2
|
+
const { CallLogModel } = require('../models/callLogModel');
|
|
3
|
+
// const { MessageLogModel } = require('../models/messageLogModel');
|
|
4
|
+
const { UserModel } = require('../models/userModel');
|
|
5
|
+
const oauth = require('../lib/oauth');
|
|
6
|
+
// const userCore = require('../handlers/user');
|
|
7
|
+
const errorMessage = require('../lib/generalErrorMessage');
|
|
8
|
+
const adapterRegistry = require('../adapter/registry');
|
|
9
|
+
|
|
10
|
+
async function upsertCallDisposition({ platform, userId, sessionId, dispositions, additionalSubmission, userSettings }) {
|
|
11
|
+
try {
|
|
12
|
+
const log = await CallLogModel.findOne({
|
|
13
|
+
where: {
|
|
14
|
+
sessionId
|
|
15
|
+
}
|
|
16
|
+
});
|
|
17
|
+
if (!log) {
|
|
18
|
+
return {
|
|
19
|
+
successful: false,
|
|
20
|
+
returnMessage: {
|
|
21
|
+
message: `Cannot find log`,
|
|
22
|
+
messageType: 'warning',
|
|
23
|
+
ttl: 3000
|
|
24
|
+
}
|
|
25
|
+
}
|
|
26
|
+
}
|
|
27
|
+
let user = await UserModel.findByPk(userId);
|
|
28
|
+
if (!user) {
|
|
29
|
+
return {
|
|
30
|
+
successful: false,
|
|
31
|
+
returnMessage: {
|
|
32
|
+
message: `Cannot find user`,
|
|
33
|
+
messageType: 'warning',
|
|
34
|
+
ttl: 3000
|
|
35
|
+
}
|
|
36
|
+
}
|
|
37
|
+
}
|
|
38
|
+
const platformModule = adapterRegistry.getAdapter(platform);
|
|
39
|
+
const authType = platformModule.getAuthType();
|
|
40
|
+
let authHeader = '';
|
|
41
|
+
switch (authType) {
|
|
42
|
+
case 'oauth':
|
|
43
|
+
const oauthApp = oauth.getOAuthApp((await platformModule.getOauthInfo({ tokenUrl: user?.platformAdditionalInfo?.tokenUrl, hostname: user?.hostname })));
|
|
44
|
+
user = await oauth.checkAndRefreshAccessToken(oauthApp, user);
|
|
45
|
+
authHeader = `Bearer ${user.accessToken}`;
|
|
46
|
+
break;
|
|
47
|
+
case 'apiKey':
|
|
48
|
+
const basicAuth = platformModule.getBasicAuth({ apiKey: user.accessToken });
|
|
49
|
+
authHeader = `Basic ${basicAuth}`;
|
|
50
|
+
break;
|
|
51
|
+
}
|
|
52
|
+
const { logId, returnMessage, extraDataTracking } = await platformModule.upsertCallDisposition({
|
|
53
|
+
user,
|
|
54
|
+
existingCallLog: log,
|
|
55
|
+
authHeader,
|
|
56
|
+
dispositions
|
|
57
|
+
});
|
|
58
|
+
return { successful: !!logId, logId, returnMessage, extraDataTracking };
|
|
59
|
+
}
|
|
60
|
+
catch (e) {
|
|
61
|
+
console.error(`platform: ${platform} \n${e.stack} \n${JSON.stringify(e.response?.data)}`);
|
|
62
|
+
if (e.response?.status === 429) {
|
|
63
|
+
return {
|
|
64
|
+
successful: false,
|
|
65
|
+
returnMessage: errorMessage.rateLimitErrorMessage({ platform })
|
|
66
|
+
};
|
|
67
|
+
}
|
|
68
|
+
else if (e.response?.status >= 400 && e.response?.status < 410) {
|
|
69
|
+
return {
|
|
70
|
+
successful: false,
|
|
71
|
+
returnMessage: errorMessage.authorizationErrorMessage({ platform }),
|
|
72
|
+
extraDataTracking: {
|
|
73
|
+
statusCode: e.response?.status,
|
|
74
|
+
}
|
|
75
|
+
};
|
|
76
|
+
}
|
|
77
|
+
return {
|
|
78
|
+
successful: false,
|
|
79
|
+
returnMessage:
|
|
80
|
+
{
|
|
81
|
+
message: `Error dispositioning call log`,
|
|
82
|
+
messageType: 'warning',
|
|
83
|
+
details: [
|
|
84
|
+
{
|
|
85
|
+
title: 'Details',
|
|
86
|
+
items: [
|
|
87
|
+
{
|
|
88
|
+
id: '1',
|
|
89
|
+
type: 'text',
|
|
90
|
+
text: `Please check if your account has permission to UPDATE logs.`
|
|
91
|
+
}
|
|
92
|
+
]
|
|
93
|
+
}
|
|
94
|
+
],
|
|
95
|
+
ttl: 5000
|
|
96
|
+
}
|
|
97
|
+
};
|
|
98
|
+
}
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
// async function upsertMessageDisposition({ platform, userId, conversationLogId, dispositions, additionalSubmission, userSettings }) {
|
|
102
|
+
// try {
|
|
103
|
+
// const existingSameDateMessageLog = await MessageLogModel.findOne({
|
|
104
|
+
// where: {
|
|
105
|
+
// conversationLogId
|
|
106
|
+
// }
|
|
107
|
+
// });
|
|
108
|
+
// if (!existingSameDateMessageLog) {
|
|
109
|
+
// return {
|
|
110
|
+
// successful: false,
|
|
111
|
+
// returnMessage: {
|
|
112
|
+
// message: `Cannot find log`,
|
|
113
|
+
// messageType: 'warning',
|
|
114
|
+
// ttl: 3000
|
|
115
|
+
// }
|
|
116
|
+
// }
|
|
117
|
+
// }
|
|
118
|
+
// let user = await UserModel.findByPk(userId);
|
|
119
|
+
// if (!user) {
|
|
120
|
+
// return {
|
|
121
|
+
// successful: false,
|
|
122
|
+
// returnMessage: {
|
|
123
|
+
// message: `Cannot find user`,
|
|
124
|
+
// messageType: 'warning',
|
|
125
|
+
// ttl: 3000
|
|
126
|
+
// }
|
|
127
|
+
// }
|
|
128
|
+
// }
|
|
129
|
+
// const platformModule = adapterRegistry.getAdapter(platform);
|
|
130
|
+
// const authType = platformModule.getAuthType();
|
|
131
|
+
// let authHeader = '';
|
|
132
|
+
// switch (authType) {
|
|
133
|
+
// case 'oauth':
|
|
134
|
+
// const oauthApp = oauth.getOAuthApp((await platformModule.getOauthInfo({ tokenUrl: user?.platformAdditionalInfo?.tokenUrl, hostname: user?.hostname })));
|
|
135
|
+
// user = await oauth.checkAndRefreshAccessToken(oauthApp, user);
|
|
136
|
+
// authHeader = `Bearer ${user.accessToken}`;
|
|
137
|
+
// break;
|
|
138
|
+
// case 'apiKey':
|
|
139
|
+
// const basicAuth = platformModule.getBasicAuth({ apiKey: user.accessToken });
|
|
140
|
+
// authHeader = `Basic ${basicAuth}`;
|
|
141
|
+
// break;
|
|
142
|
+
// }
|
|
143
|
+
// const { logId, returnMessage, extraDataTracking } = await platformModule.upsertMessageDisposition({
|
|
144
|
+
// user,
|
|
145
|
+
// existingMessageLog: existingSameDateMessageLog,
|
|
146
|
+
// authHeader,
|
|
147
|
+
// dispositions
|
|
148
|
+
// });
|
|
149
|
+
// return { successful: !!logId, logId, returnMessage, extraDataTracking };
|
|
150
|
+
// }
|
|
151
|
+
// catch (e) {
|
|
152
|
+
// console.error(`platform: ${platform} \n${e.stack} \n${JSON.stringify(e.response?.data)}`);
|
|
153
|
+
// if (e.response?.status === 429) {
|
|
154
|
+
// return {
|
|
155
|
+
// successful: false,
|
|
156
|
+
// returnMessage: errorMessage.rateLimitErrorMessage({ platform })
|
|
157
|
+
// };
|
|
158
|
+
// }
|
|
159
|
+
// else if (e.response?.status >= 400 && e.response?.status < 410) {
|
|
160
|
+
// return {
|
|
161
|
+
// successful: false,
|
|
162
|
+
// returnMessage: errorMessage.authorizationErrorMessage({ platform }),
|
|
163
|
+
// extraDataTracking: {
|
|
164
|
+
// statusCode: e.response?.status,
|
|
165
|
+
// }
|
|
166
|
+
// };
|
|
167
|
+
// }
|
|
168
|
+
// return {
|
|
169
|
+
// successful: false,
|
|
170
|
+
// returnMessage:
|
|
171
|
+
// {
|
|
172
|
+
// message: `Error dispositioning message log`,
|
|
173
|
+
// messageType: 'warning',
|
|
174
|
+
// details: [
|
|
175
|
+
// {
|
|
176
|
+
// title: 'Details',
|
|
177
|
+
// items: [
|
|
178
|
+
// {
|
|
179
|
+
// id: '1',
|
|
180
|
+
// type: 'text',
|
|
181
|
+
// text: `Please check if your account has correct permissions.`
|
|
182
|
+
// }
|
|
183
|
+
// ]
|
|
184
|
+
// }
|
|
185
|
+
// ],
|
|
186
|
+
// ttl: 5000
|
|
187
|
+
// }
|
|
188
|
+
// };
|
|
189
|
+
// }
|
|
190
|
+
// }
|
|
191
|
+
|
|
192
|
+
|
|
193
|
+
exports.upsertCallDisposition = upsertCallDisposition;
|
|
194
|
+
// exports.upsertMessageDisposition = upsertMessageDisposition;
|