ef-keycloak-connect 1.4.1 → 1.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ef-keycloak-connect",
-  "version": "1.4.1",
+  "version": "1.5.1",
   "description": "Node JS keycloak adapter for authentication and authorization.",
   "main": "index.js",
   "scripts": {

package/services/keycloakService.js

@@ -148,8 +148,8 @@ class KeycloakService extends Keycloak {
                                             let getuserDetails = await requestController.httpRequest(config, true);
                                             let responseObject = {
                                                 'id': getuserDetails.data[0].id,
-                                                'firstName': getuserDetails.data[0].firstName,
-                                                'lastName': getuserDetails.data[0].lastName,
+                                                'firstName': getuserDetails.data[0].firstName ? getuserDetails.data[0].firstName : '',
+                                                'lastName': getuserDetails.data[0].lastName ? getuserDetails.data[0].lastName : '',
                                                 'username': getuserDetails.data[0].username,
                                                 'permittedResources': {
                                                     'Resources': intrsopectionResponse.data.authorization.permissions
@@ -184,11 +184,21 @@ class KeycloakService extends Keycloak {
                                                 resolve(finalObject);
 
                                             } catch (error) {
-                                                reject("Error while fetching Groups of User in Auth Process" + error);
+                                                console.log("Error while fetching Groups of User in Auth Process ");
+                                                reject(error);
                                             }
                                         }
                                         catch (error) {
-                                            reject("Get all users request not sent" + error);
+
+                                            if (error.response) {
+                                                reject({
+                                                    error: 'Error while fetching the User Details during Login Process',
+                                                    status: error.response.status,
+                                                    errorMessage: error.response.data
+                                                });
+                                            }
+
+                                            reject("Error while fetching the User Details during Login Process " + error);
                                         }
                                     }
                                     else {
@@ -197,25 +207,61 @@ class KeycloakService extends Keycloak {
                                     }
                                 }
                                 catch (error) {
-                                    reject("Admin Request not sent" + error);
+
+                                    if (error.response) {
+                                        reject({
+                                            error: 'Error while generating Admin Access Token',
+                                            status: error.response.status,
+                                            errorMessage: error.response.data
+                                        });
+                                    }
+
+                                    reject("Error while generating Admin Access Token " + error);
                                 }
                             }
                             catch (error) {
-                                reject(error);
+                                if (error.response) {
+                                    reject({
+                                        error: 'Error while fetching Introspect token',
+                                        status: error.response.status,
+                                        errorMessage: error.response.data
+                                    });
+                                }
+
+                                reject("Error while fetching Introspect token " + error);
                             }
                         } else {
                             reject("RPT Request Failed");
                         }
                     } catch (error) {
-                        reject(error);
+
+                        if (error.response) {
+                            reject({
+                                error: 'Error while fetching RPT token, Please make sure all required Permissions & ' +
+                                    'Groups are assigned to User. For example, user with role agent must be assigned agents_permission group & all required permissions are created',
+                                status: error.response.status,
+                                errorMessage: error.response.data
+                            });
+                        }
+
+                        reject("Error while fetching RPT token " + error);
                     }
                 }
                 else {
                     reject("Access Token Request Failed");
                 }
             }
-            catch (er) {
-                reject(er);
+            catch (error) {
+
+                if (error.response) {
+                    reject({
+                        error: 'Error while generating Access Token',
+                        status: error.response.status,
+                        errorMessage: error.response.data
+                    });
+                }
+
+                reject("Error while generating Access Token " + error);
             }
         });
     }
@@ -679,42 +725,49 @@ class KeycloakService extends Keycloak {
 
                             let filteredTeams = groups.filter(group => !group.name.includes('_permission'));
 
+                            if (filteredTeams.length > 0) {
 
-                            userTeam = {
-                                'teamId': filteredTeams[0].id,
-                                'teamName': filteredTeams[0].name
-                            }
+                                userTeam = {
+                                    'teamId': filteredTeams[0].id,
+                                    'teamName': filteredTeams[0].name
+                                }
 
-                            team.userTeam = userTeam;
+                                team.userTeam = userTeam;
 
-                            config.method = 'get';
-                            delete config.data;
-                            delete config.url;
+                                config.method = 'get';
+                                delete config.data;
+                                delete config.url;
 
-                            let URL3 = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/groups';
-                            config.url = URL3;
-                            config.headers.Authorization = 'Bearer ' + token;
+                                let URL3 = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/groups';
+                                config.url = URL3;
+                                config.headers.Authorization = 'Bearer ' + token;
 
-                            try {
+                                try {
 
-                                let allGroups = await requestController.httpRequest(config, true);
+                                    let allGroups = await requestController.httpRequest(config, true);
 
-                                for (let group of allGroups.data) {
+                                    for (let group of allGroups.data) {
 
-                                    let result = await teamsService.getGroupByGroupID(group.id, username, token, keycloakConfig);
+                                        let result = await teamsService.getGroupByGroupID(group.id, username, token, keycloakConfig);
 
-                                    if (result && !result.teamName.includes('_permission')) {
-                                        supervisedTeams.push(result);
-                                    }
-                                };
+                                        if (result && !result.teamName.includes('_permission')) {
+                                            supervisedTeams.push(result);
+                                        }
+                                    };
 
-                                team.supervisedTeams = supervisedTeams;
-                                resolve(team);
+                                    team.supervisedTeams = supervisedTeams;
+                                    resolve(team);
 
-                            } catch (er) {
+                                } catch (er) {
 
-                                error = await this.checkErrorType(er);
-                                reject(error);
+                                    error = await this.checkErrorType(er);
+                                    reject(error);
+                                }
+                            } else {
+                                reject({
+                                    status: 403,
+                                    errorMessage: 'No Teams group assigned to User, please assign one Team to user. If user has no team then assign it default group.'
+                                });
                             }
                         } else {
 
@@ -913,6 +966,166 @@ class KeycloakService extends Keycloak {
 
     }
 
+    //function to be used only in teams implementation. We give the list of ids of groups and it returns all its members and supervisors
+    async getGroupMembers(groupIds) {
+
+        return new Promise(async (resolve, reject) => {
+
+            let token;
+            let groupsData = [];
+            var URL = keycloakConfig["auth-server-url"] + 'realms/' + keycloakConfig.realm + '/protocol/openid-connect/token';
+
+            var config = {
+                method: 'post',
+                url: URL,
+                headers: {
+                    'Accept': 'application/json',
+                    'cache-control': 'no-cache',
+                    'Content-Type': 'application/x-www-form-urlencoded'
+                },
+                data: {
+                    client_id: keycloakConfig.CLIENT_ID,
+                    username: keycloakConfig.USERNAME_ADMIN,
+                    password: keycloakConfig.PASSWORD_ADMIN,
+                    grant_type: keycloakConfig.GRANT_TYPE,
+                    client_secret: keycloakConfig.credentials.secret
+                }
+            };
+
+            try {
+
+                let adminTokenResponse = await requestController.httpRequest(config, true);
+                token = adminTokenResponse.data.access_token;
+
+                if (groupIds.length > 0) {
+
+                    config.method = 'get';
+                    delete config.data;
+                    delete config.url;
+                    config.headers.Authorization = 'Bearer ' + token;
+
+
+                    for (let i = 0; i < groupIds.length; i++) {
+
+                        try {
+
+                            let groupData = {};
+
+                            let URL2 = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/groups/' + groupIds[i] + '/';
+                            config.url = URL2;
+                            let groupInfo = await requestController.httpRequest(config, true);
+
+                            groupData.teamId = groupInfo.data.id;
+                            groupData.teamName = groupInfo.data.name;
+
+                            if (Object.keys(groupInfo.data.attributes).length == 0) {
+
+                                groupData.supervisors = [];
+                            } else {
+
+                                let attributes = groupInfo.data.attributes;
+
+                                if ('supervisor' in attributes) {
+
+                                    let supervisorList = attributes['supervisor'][0].split(",");
+                                    let supervisors = [];
+
+                                    for (let j = 0; j < supervisorList.length; j++) {
+
+                                        let URL3 = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/users?username=' + supervisorList[j] + '&exact=true';
+                                        config.url = URL3;
+
+
+                                        try {
+
+                                            let supervisorUser = await requestController.httpRequest(config, true);
+
+                                            if (supervisorUser.data.length > 0) {
+                                                supervisors.push({
+                                                    supervisorId: supervisorUser.data[0].id,
+                                                    supervisorName: supervisorUser.data[0].username
+                                                })
+                                            }
+                                        } catch (err) {
+                                            if (err.response) {
+                                                reject({
+                                                    status: err.response.status,
+                                                    errorMessage: err.response.data
+                                                });
+                                            }
+
+                                            reject(err);
+
+                                        }
+                                    }
+
+                                    groupData.supervisors = supervisors;
+
+                                }
+
+                            }
+
+                            let URL4 = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/groups/' + groupIds[i] + '/members';
+                            config.url = URL4;
+                            let users = await requestController.httpRequest(config, true);
+
+
+                            if (users.data.length > 0) {
+
+                                let agents = users.data;
+                                agents = agents.map(agent => {
+                                    return {
+                                        agentId: agent.id,
+                                        agentName: agent.username
+                                    }
+                                });
+
+                                groupData.agents = agents;
+
+                            } else {
+                                groupData.agents = [];
+                            }
+
+                            groupsData.push(groupData);
+
+                        } catch (err) {
+
+                            if (err.response) {
+                                reject({
+                                    status: err.response.status,
+                                    errorMessage: err.response.data
+                                });
+                            }
+
+                            reject(err);
+
+                        }
+
+                    }
+
+                    resolve(groupsData);
+                }
+
+                resolve([]);
+
+            } catch (err) {
+
+                if (err.response) {
+                    reject({
+                        status: err.response.status,
+                        errorMessage: err.response.data
+                    });
+                }
+
+                reject(err);
+
+            }
+
+        });
+
+    }
+
+
     // this function requires comma separated list of roles in parameter e.g ["robot","human","customer"];
     getUsersByRole(keycloak_roles) {
         return new Promise(async (resolve, reject) => {
@@ -1060,10 +1273,16 @@ class KeycloakService extends Keycloak {
 
             }
             catch (err) {
-                reject({
-                    "status": err.response.status,
-                    "message": err.response.data.error_description
-                });
+
+                if (err.response) {
+                    reject({
+                        "status": err.response.status,
+                        "message": err.response.data
+                    });
+                }
+
+                reject('Error while assignment of roles to User: ' + err);
+
             }
 
         });
@@ -1073,14 +1292,14 @@ class KeycloakService extends Keycloak {
     async createUser(username, password, token, userRoles) {
 
         let assignRole = [];
-        let assignGroups = ['agents_permission', 'default'];
+        let assignGroups = userRoles.includes('supervisor') ? ["agents_permission", "default", "senior_agents_permission"] : ["agents_permission", "default"];
 
         return new Promise(async (resolve, reject) => {
 
 
             for (let group of assignGroups) {
 
-                let URL2 = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/groups?search=' + group;
+                let URL2 = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/groups?search=' + group + '&exact=true';
 
                 let config1 = {
                     method: 'get',
@@ -1100,10 +1319,16 @@ class KeycloakService extends Keycloak {
 
                     }
                 } catch (err) {
-                    reject({
-                        "status": err.response.status,
-                        "message": err.response.data.error_description
-                    });
+
+                    if (err.response) {
+                        reject({
+                            "status": err.response.status,
+                            "message": err.response.data
+                        });
+                    }
+
+                    reject('Error while fetching group against group-name: ' + err);
+
                 }
 
             }
@@ -1121,7 +1346,7 @@ class KeycloakService extends Keycloak {
                         temporary: false
                     }
                 ],
-                groups: ["agents_permission", "default"]
+                groups: assignGroups
             }
 
             let config = {
@@ -1163,12 +1388,24 @@ class KeycloakService extends Keycloak {
                         });
                     }
 
-                    //assigning role to user
-                    let roleAssigned = await this.assignRoleToUser(userId, assignRole, token);
+                    try {
+                        //assigning role to user
+                        let roleAssigned = await this.assignRoleToUser(userId, assignRole, token);
+
+                        //Role assigned with status 
+                        //Role assigned with status 
+                        //Role assigned with status 
+                        if (roleAssigned.status == 204) {
+                            resolve(tokenResponse);
+                        }
+                    } catch (err) {
+
+                        if (err.status) {
+                            reject(err);
+                        }
+
+                        reject('Error while Assignment of role to user: ' + err);
 
-                    //Role assigned with status 
-                    if (roleAssigned.status == 204) {
-                        resolve(tokenResponse);
                     }
 
                 } else {
@@ -1180,10 +1417,15 @@ class KeycloakService extends Keycloak {
 
             }
             catch (err) {
-                reject({
-                    "status": err.response.status,
-                    "message": err.response.data.error_description
-                });
+
+                if (err.response) {
+                    reject({
+                        "status": err.response.status,
+                        "message": err.response.data
+                    });
+                }
+
+                reject('Error while Creation of User: ' + err);
             }
 
         });
@@ -1508,17 +1750,17 @@ class KeycloakService extends Keycloak {
 
             } catch (err) {
 
-                if (err.response.status == 401) {
-
-                    console.log("User doesn't exist in Keycloak, syncing finesse user in keycloak...");
+                if (err.status) {
 
-                } else {
+                    if (err.status == 401) {
 
-                    throw ({
-                        "status": err.response.status,
-                        "message": err.response.data.error_description
-                    });
+                        console.log("User doesn't exist in Keycloak, syncing finesse user in keycloak...");
+                    } else {
+                        throw (err);
+                    }
 
+                } else {
+                    throw ("Error while fetching keycloak User token: " + err);
                 }
 
             } finally {
@@ -1540,10 +1782,12 @@ class KeycloakService extends Keycloak {
                             });
 
                         } else {
-                            throw ({
-                                "status": err.response.status,
-                                "message": "Error While getting Keycloak admin token: " + err.response.data.error_description
-                            });
+
+                            if (err.status) {
+                                throw (err);
+                            }
+
+                            throw ("Error While getting Keycloak admin token: " + err);
                         }
 
                     }
@@ -1586,12 +1830,11 @@ class KeycloakService extends Keycloak {
 
                         } else {
 
-                            console.log(err);
+                            if (err.status) {
+                                throw (err);
+                            }
 
-                            throw ({
-                                "status": err.response.status,
-                                "message": "Error While creating Keycloak user: " + err.response.data.error_description
-                            });
+                            throw ("Error While creating Keycloak user: " + err);
                         }
                     }
                 }
@@ -1667,10 +1910,14 @@ class KeycloakService extends Keycloak {
 
         } else {
 
-            return ({
-                "status": err.response.status,
-                "message": "Error: " + err.response.data.error_description
-            });
+            if (err.response) {
+                return ({
+                    status: error.response.status,
+                    errorMessage: error.response.data
+                });
+            }
+
+            return (err);
         }
     }