ef-keycloak-connect 1.6.0 → 1.6.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.
Files changed (5) hide show
  1. package/package.json +1 -1
  2. package/services/errorService.js +32 -0
  3. package/services/finesseService.js +101 -63
  4. package/services/keycloakService.js +2409 -1412
  5. package/services/teamsService.js +99 -102
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "ef-keycloak-connect",
3
- "version": "1.6.0",
3
+ "version": "1.6.1",
4
4
  "description": "Node JS keycloak adapter for authentication and authorization.",
5
5
  "main": "index.js",
6
6
  "scripts": {
package/services/errorService.js ADDED
@@ -0,0 +1,32 @@
1
+
2
+
3
+ class ErrorService {
4
+
5
+ constructor () {
6
+
7
+ }
8
+
9
+ async handleError( err ) {
10
+
11
+ if ( err.code == "ETIMEDOUT" ) {
12
+
13
+ return {
14
+ "Keycloak login status": 408,
15
+ "keycloak login message": `Keycloak server unaccessable against URL: ${keycloakConfig[ "auth-server-url" ]}`,
16
+ };
17
+
18
+ } else {
19
+
20
+ if ( err.response ) {
21
+ return {
22
+ status: err.response.status,
23
+ reason: err.response.data,
24
+ };
25
+ }
26
+
27
+ return err;
28
+ }
29
+ }
30
+ }
31
+
32
+ module.exports = ErrorService;
package/services/finesseService.js CHANGED
@@ -1,20 +1,23 @@
1
- var requestController = require("../controller/requestController.js");
2
- const https = require('https');
1
+ const parseXMLString = require( 'xml2js' ).parseString;
2
+ const https = require( 'https' );
3
+
4
+ var requestController = require( "../controller/requestController.js" );
3
5
 
4
6
  class FinesseService {
5
7
 
6
- constructor() {
8
+ constructor () {
7
9
 
8
10
  }
9
11
 
10
12
 
11
- async authenticateUserViaFinesse(username, password, finesseUrl) {
13
+ async authenticateUserViaFinesse( username, password, finesseUrl ) {
12
14
 
13
- return new Promise(async (resolve, reject) => {
15
+ return new Promise( async ( resolve, reject ) => {
14
16
 
15
- var URL = finesseUrl + '/finesse/api/User/' + username;
17
+ var URL = finesseUrl + '/finesse/api/User/' + 'shabbersup@ucce.ipcc';
18
+ let userObject = {};
16
19
 
17
- let encodedCredentials = await this.maskCredentials(username, password);
20
+ let encodedCredentials = await this.maskCredentials( username, password );
18
21
 
19
22
  let config = {
20
23
  method: 'get',
@@ -23,44 +26,79 @@ class FinesseService {
23
26
  'Authorization': `Basic ${encodedCredentials}`
24
27
  },
25
28
  //disable ssl
26
- httpsAgent: new https.Agent({ rejectUnauthorized: false })
29
+ httpsAgent: new https.Agent( { rejectUnauthorized: false } )
27
30
  };
28
31
 
29
32
  try {
30
33
 
31
- let tokenResponse = await requestController.httpRequest(config, true);
34
+ let tokenResponse = await requestController.httpRequest( config, true );
35
+
36
+ parseXMLString( tokenResponse.data, async ( err, result ) => {
37
+
38
+ if ( err ) {
39
+ console.error( err );
40
+ } else {
41
+ if ( result.User ) {
42
+
43
+ let user = result.User;
44
+
45
+ userObject = {
46
+ username: user.loginName[ 0 ],
47
+ firstName: user.firstName[ 0 ],
48
+ lastName: user.lastName[ 0 ],
49
+ roles: ( user.roles[ 0 ].role ).map( role => role.toLowerCase() ),
50
+ group: ( user.teamName == '' || user.teamName == null ) ? [ 'default' ] : { id: user.teamId[ 0 ], name: user.teamName[ 0 ] }
51
+ }
52
+
53
+ if ( user.teams ) {
54
+
55
+ if ( user.teams[ 0 ].Team ) {
56
+
57
+ userObject.supervisedGroups = ( user.teams[ 0 ].Team ).map( team => {
58
+ return {
59
+ id: team.id[ 0 ],
60
+ name: team.name[ 0 ]
61
+ }
62
+ } );
63
+ }
64
+ }
65
+ }
66
+ }
67
+ }
68
+ );
32
69
 
33
- resolve({
70
+ resolve( {
71
+ 'data': userObject,
34
72
  'status': tokenResponse.status
35
- });
73
+ } );
36
74
 
37
75
  }
38
- catch (er) {
76
+ catch ( er ) {
39
77
 
40
- if (er.code == "ENOTFOUND") {
78
+ if ( er.code == "ENOTFOUND" ) {
41
79
 
42
- resolve({
80
+ reject( {
43
81
  'finesse login status': 408,
44
82
  'finesse login message': `finesse server not accessible against URL: ${finesseUrl}`
45
- });
83
+ } );
46
84
 
47
- } else if (er.response) {
85
+ } else if ( er.response ) {
48
86
 
49
- resolve({
87
+ reject( {
50
88
  'finesse login status': er.response.status,
51
89
  'finesse login message': er.response.statusText
52
- });
90
+ } );
53
91
 
54
92
  }
55
93
 
56
94
  }
57
95
 
58
- });
96
+ } );
59
97
  }
60
98
 
61
- async authenticateUserViaFinesseSSO(username, finesseToken, finesseUrl) {
99
+ async authenticateUserViaFinesseSSO( username, finesseToken, finesseUrl ) {
62
100
 
63
- return new Promise(async (resolve, reject) => {
101
+ return new Promise( async ( resolve, reject ) => {
64
102
 
65
103
  var URL = finesseUrl + '/finesse/api/User/' + username;
66
104
 
@@ -71,47 +109,47 @@ class FinesseService {
71
109
  'Authorization': `Bearer ${finesseToken}`
72
110
  },
73
111
  //disable ssl
74
- httpsAgent: new https.Agent({ rejectUnauthorized: false })
112
+ httpsAgent: new https.Agent( { rejectUnauthorized: false } )
75
113
  };
76
114
 
77
115
  try {
78
116
 
79
- let tokenResponse = await requestController.httpRequest(config, true);
117
+ let tokenResponse = await requestController.httpRequest( config, true );
80
118
 
81
- resolve({
119
+ resolve( {
82
120
  'status': tokenResponse.status
83
- });
121
+ } );
84
122
 
85
123
  }
86
- catch (er) {
124
+ catch ( er ) {
87
125
 
88
- if (er.code == "ENOTFOUND") {
126
+ if ( er.code == "ENOTFOUND" ) {
89
127
 
90
- resolve({
128
+ reject( {
91
129
  'finesse login status': 408,
92
130
  'finesse login message': `finesse server not accessible against URL: ${finesseUrl}`
93
- });
131
+ } );
94
132
 
95
- } else if (er.response) {
133
+ } else if ( er.response ) {
96
134
 
97
- resolve({
135
+ reject( {
98
136
  'finesse login status': er.response.status,
99
137
  'finesse login message': er.response.statusText
100
- });
138
+ } );
101
139
 
102
140
  }
103
141
  }
104
142
 
105
- });
143
+ } );
106
144
  }
107
145
 
108
- async getCiscoTeams(username, password, finesseUrl) {
146
+ async getCiscoTeams( username, password, finesseUrl ) {
109
147
 
110
- return new Promise(async (resolve, reject) => {
148
+ return new Promise( async ( resolve, reject ) => {
111
149
 
112
150
  var URL = finesseUrl + '/finesse/api/Teams';
113
151
 
114
- let encodedCredentials = await this.maskCredentials(username, password);
152
+ let encodedCredentials = await this.maskCredentials( username, password );
115
153
 
116
154
  let config = {
117
155
  method: 'get',
@@ -120,46 +158,46 @@ class FinesseService {
120
158
  'Authorization': `Basic ${encodedCredentials}`
121
159
  },
122
160
  //disable ssl
123
- httpsAgent: new https.Agent({ rejectUnauthorized: false })
161
+ httpsAgent: new https.Agent( { rejectUnauthorized: false } )
124
162
  };
125
163
 
126
164
  try {
127
165
 
128
- let tokenResponse = await requestController.httpRequest(config, true);
166
+ let tokenResponse = await requestController.httpRequest( config, true );
129
167
 
130
- resolve(tokenResponse.data);
168
+ resolve( tokenResponse.data );
131
169
 
132
170
  }
133
- catch (er) {
171
+ catch ( er ) {
134
172
 
135
- if (er.code == "ENOTFOUND") {
173
+ if ( er.code == "ENOTFOUND" ) {
136
174
 
137
- resolve({
175
+ resolve( {
138
176
  'finesse login status': 408,
139
177
  'finesse login message': `finesse server not accessible against URL: ${finesseUrl}`
140
- });
178
+ } );
141
179
 
142
- } else if (er.response) {
180
+ } else if ( er.response ) {
143
181
 
144
- resolve({
182
+ resolve( {
145
183
  'finesse login status': er.response.status,
146
184
  'finesse login message': er.response.statusText
147
- });
185
+ } );
148
186
 
149
187
  }
150
188
 
151
189
  }
152
190
 
153
- });
191
+ } );
154
192
  }
155
193
 
156
- async getCiscoUsers(username, password, finesseUrl) {
194
+ async getCiscoUsers( username, password, finesseUrl ) {
157
195
 
158
- return new Promise(async (resolve, reject) => {
196
+ return new Promise( async ( resolve, reject ) => {
159
197
 
160
198
  var URL = finesseUrl + '/finesse/api/Users';
161
199
 
162
- let encodedCredentials = await this.maskCredentials(username, password);
200
+ let encodedCredentials = await this.maskCredentials( username, password );
163
201
 
164
202
  let config = {
165
203
  method: 'get',
@@ -168,42 +206,42 @@ class FinesseService {
168
206
  'Authorization': `Basic ${encodedCredentials}`
169
207
  },
170
208
  //disable ssl
171
- httpsAgent: new https.Agent({ rejectUnauthorized: false })
209
+ httpsAgent: new https.Agent( { rejectUnauthorized: false } )
172
210
  };
173
211
 
174
212
  try {
175
213
 
176
- let tokenResponse = await requestController.httpRequest(config, true);
214
+ let tokenResponse = await requestController.httpRequest( config, true );
177
215
 
178
- resolve(tokenResponse.data);
216
+ resolve( tokenResponse.data );
179
217
 
180
218
  }
181
- catch (er) {
219
+ catch ( er ) {
182
220
 
183
- if (er.code == "ENOTFOUND") {
221
+ if ( er.code == "ENOTFOUND" ) {
184
222
 
185
- resolve({
223
+ resolve( {
186
224
  'finesse login status': 408,
187
225
  'finesse login message': `finesse server not accessible against URL: ${finesseUrl}`
188
- });
226
+ } );
189
227
 
190
- } else if (er.response) {
228
+ } else if ( er.response ) {
191
229
 
192
- resolve({
230
+ resolve( {
193
231
  'finesse login status': er.response.status,
194
232
  'finesse login message': er.response.statusText
195
- });
233
+ } );
196
234
 
197
235
  }
198
236
 
199
237
  }
200
238
 
201
- });
239
+ } );
202
240
  }
203
241
 
204
- async maskCredentials(username, password) {
242
+ async maskCredentials( username, password ) {
205
243
 
206
- let token = Buffer.from(`${username}:${password}`, 'utf8').toString('base64');
244
+ let token = Buffer.from( `${username}:${password}`, 'utf8' ).toString( 'base64' );
207
245
  return token;
208
246
 
209
247
  }