ef-keycloak-connect 1.2.4 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ef-keycloak-connect",
-  "version": "1.2.4",
+  "version": "1.3.0",
   "description": "Node JS keycloak adapter for authentication and authorization.",
   "main": "index.js",
   "scripts": {
@@ -19,4 +19,4 @@
     "joi": "^17.6.0",
     "keycloak-connect": "^10.0.2"
   }
-}
+}

package/services/keycloakService.js

@@ -6,15 +6,18 @@ var memory = new session.MemoryStore();
 var keycloakConfig = null;
 
 const FinesseService = require('./finesseService');
+const TeamsService = require('./teamsService');
+
 const finesseService = new FinesseService();
+const teamsService = new TeamsService();
 
-class KeycloakService extends Keycloak{
+class KeycloakService extends Keycloak {
 
     constructor(config) {
 
-        keycloakConfig =  {...config};
+        keycloakConfig = { ...config };
         super({ store: memory }, keycloakConfig);   //initialising keycloak-connect   //Keycloak = new Keycloak({store: memory}, config);
-       // this.keycloakConfig = config;
+        // this.keycloakConfig = config;
     }
 
     //Based on the attributes it either authenticate keycloak user or finesse user.
@@ -23,23 +26,23 @@ class KeycloakService extends Keycloak{
         let token = '';
 
         // If finesseUrl is empty it means normal keycloak auth is required.
-        if(finesseUrl == ''){
+        if (finesseUrl == '') {
 
             token = await this.getKeycloakTokenWithIntrospect(user_name, user_password, realm_name);
             return token;
 
-        }else{
+        } else {
 
             // Finesse Auth, takes userRole in argument to create user along with role.
             token = await this.authenticateFinesse(user_name, user_password, finesseUrl, userRoles, finesseToken)
             return token;
-            
+
         }
-        
+
     }
 
-    getAccessToken(user_name, user_password){
-        
+    getAccessToken(user_name, user_password) {
+
         return new Promise(async (resolve, reject) => {
 
             var URL = keycloakConfig["auth-server-url"] + 'realms/' + keycloakConfig["realm"] + '/protocol/openid-connect/token';
@@ -74,7 +77,7 @@ class KeycloakService extends Keycloak{
     }
 
     // this function requires an Admin user in keycloak.json having realm-management roles
-    async getKeycloakTokenWithIntrospect(user_name, user_password, realm_name){
+    async getKeycloakTokenWithIntrospect(user_name, user_password, realm_name) {
 
         return new Promise(async (resolve, reject) => {
             let token;
@@ -96,7 +99,7 @@ class KeycloakService extends Keycloak{
                     grant_type: keycloakConfig.GRANT_TYPE,
                 },
             };
-            //console.log(config);
+
             try {
                 //  T.O.K.E.N   R.E.Q.U.E.S.T   # 1   ( P.E.R.M.I.S.S.I.O.N.S   N.O.T    I.N.C.L.U.D.E.D) 
                 let tokenResponse = await requestController.httpRequest(config, true);
@@ -116,11 +119,12 @@ class KeycloakService extends Keycloak{
                             config.data.token = token;
                             URL = URL + '/introspect'
                             config.url = URL;
-                            //  T.O.K.E.N   R.E.Q.U.E.S.T   # 3   (A.C.C.E.S.S   T.O.K.E.N   I.N.T.R.O.S.P.E.C.T.I.O.N)                 
 
+                            //  T.O.K.E.N   R.E.Q.U.E.S.T   # 3   (A.C.C.E.S.S   T.O.K.E.N   I.N.T.R.O.S.P.E.C.T.I.O.N)
                             try {
                                 let intrsopectionResponse = await requestController.httpRequest(config, true);
                                 intrsopectionResponse.data.access_token = token;
+
                                 //  T.O.K.E.N   R.E.Q.U.E.S.T   # 4   ( A.D.M.I.N.  T.O.K.E.N) 
                                 try {
                                     config.data.username = keycloakConfig.USERNAME_ADMIN;
@@ -152,16 +156,29 @@ class KeycloakService extends Keycloak{
                                             };
 
                                             //Adding user custom attribute to our token object data.
-                                            if(getuserDetails.data[0].attributes){
+                                            if (getuserDetails.data[0].attributes) {
                                                 responseObject.attributes = getuserDetails.data[0].attributes;
                                             }
 
-                                            let finalObject = {
-                                                'token': userToken,
-                                                'keycloak_User': responseObject
-                                            }
-                                            resolve(finalObject);
+                                            delete config.headers.Authorization;
+                                            delete config.data;
 
+                                            //Fetching Groups data for each user.
+                                            try {
+
+                                                let teamData = await this.getUserSupervisedGroups(responseObject.id, responseObject.username);
+                                                responseObject.userTeam = teamData.userTeam;
+                                                responseObject.supervisedTeams = teamData.supervisedTeams;
+
+                                                let finalObject = {
+                                                    'token': userToken,
+                                                    'keycloak_User': responseObject
+                                                }
+                                                resolve(finalObject);
+
+                                            } catch (error) {
+                                                reject("Error while fetching Groups of User in Auth Process" + error);
+                                            }
                                         }
                                         catch (error) {
                                             reject("Get all users request not sent" + error);
@@ -196,6 +213,48 @@ class KeycloakService extends Keycloak{
         });
     }
 
+    async getUserInfoFromToken(username, token) {
+
+        return new Promise(async (resolve, reject) => {
+
+            var URL = keycloakConfig["auth-server-url"] + 'realms/' + keycloakConfig.realm + '/protocol/openid-connect/token/introspect';
+
+            let config = {
+                method: 'post',
+                url: URL,
+                headers: {
+                    'Accept': 'application/json',
+                    'cache-control': 'no-cache',
+                    'Content-Type': 'application/x-www-form-urlencoded'
+                },
+                data: {
+                    username: username,
+                    client_id: keycloakConfig.CLIENT_ID,
+                    client_secret: keycloakConfig.credentials.secret,
+                    token: token
+                }
+            };
+
+            try {
+
+                let userInfo = await requestController.httpRequest(config, true);
+                if (!(userInfo.data.active)) {
+                    resolve({
+                        'status': 401,
+                        'message': 'Provided User Access Token is Expired.'
+                    });
+                }
+
+                let clientRoles = userInfo.data.resource_access;
+                resolve(clientRoles);
+
+            } catch (error) {
+                reject(error);
+            }
+        });
+
+    }
+
     createResource(resource_name, resource_scope = keycloakConfig.SCOPE_NAME) {
         return new Promise(async (resolve, reject) => {
 
@@ -369,7 +428,7 @@ class KeycloakService extends Keycloak{
                 config.data = JSON.stringify(config.data);
 
                 try {
-                    let policyResponse = await requestController.httpRequest(config,false);
+                    let policyResponse = await requestController.httpRequest(config, false);
                     resolve(policyResponse);
                 } catch (error) {
                     reject("Policy error" + error);
@@ -383,7 +442,7 @@ class KeycloakService extends Keycloak{
 
     }
 
-    createPermission(resourceName, policyName, permissionName, scopeName){
+    createPermission(resourceName, policyName, permissionName, scopeName) {
 
         return new Promise(async (resolve, reject) => {
             let token;
@@ -433,7 +492,7 @@ class KeycloakService extends Keycloak{
                 config.data = JSON.stringify(config.data);
 
                 try {
-                    let policyResponse = await requestController.httpRequest(config,false);
+                    let policyResponse = await requestController.httpRequest(config, false);
                     resolve(policyResponse);
                 } catch (error) {
                     reject("Policy error" + error);
@@ -503,7 +562,7 @@ class KeycloakService extends Keycloak{
         });
     }
 
-    revokeUseronResource(resource_name, keycloak_user_id){
+    revokeUseronResource(resource_name, keycloak_user_id) {
         return new Promise(async (resolve, reject) => {
             let token;
             try {
@@ -558,6 +617,290 @@ class KeycloakService extends Keycloak{
         });
     }
 
+    //function to be used only in teams implementation
+    async getUserSupervisedGroups(userId, username) {
+
+        return new Promise(async (resolve, reject) => {
+
+            let error;
+            let token;
+            var URL = keycloakConfig["auth-server-url"] + 'realms/' + keycloakConfig.realm + '/protocol/openid-connect/token';
+
+            try {
+
+                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;
+
+                    config.method = 'get';
+                    delete config.data;
+                    delete config.url;
+
+                    let URL2 = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/users/' + userId + '/groups';
+                    config.url = URL2;
+                    config.headers.Authorization = 'Bearer ' + token;
+
+                    try {
+
+                        let userGroup = await requestController.httpRequest(config, true);
+                        let team = {};
+
+                        if (userGroup.data.length != 0) {
+
+
+                            let group = userGroup.data;
+                            let userTeam = {};
+                            let supervisedTeams = [];
+
+
+                            userTeam = {
+                                'teamId': group[0].id,
+                                'teamName': group[0].name
+                            }
+
+                            team.userTeam = userTeam;
+
+                            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;
+
+                            try {
+
+                                let allGroups = await requestController.httpRequest(config, true);
+
+                                for (let group of allGroups.data) {
+
+                                    let result = await teamsService.getGroupByGroupID(group.id, username, token, keycloakConfig);
+
+                                    if (result) {
+                                        supervisedTeams.push(result);
+                                    }
+                                };
+
+                                team.supervisedTeams = supervisedTeams;
+                                resolve(team);
+
+                            } catch (er) {
+
+                                error = await this.checkErrorType(er);
+                                reject(error);
+                            }
+                        } else {
+
+                            team.userTeam = {};
+                            team.supervisedTeams = [];
+
+                            resolve(team);
+                        }
+
+                    } catch (er) {
+
+                        error = await this.checkErrorType(er);
+                        reject(error);
+                    }
+                } catch (er) {
+
+                    error = await this.checkErrorType(er);
+                    reject(error);
+                }
+            } catch (er) {
+
+                error = await this.checkErrorType(er);
+                reject(error);
+            };
+        });
+
+    }
+
+    //function to be used only in teams implementation
+    async getTeamUsers(keycloakObj, groupsIdsArr, userToken) {
+
+        return new Promise(async (resolve, reject) => {
+
+            let token;
+            let message;
+            var URL = keycloakConfig["auth-server-url"] + 'realms/' + keycloakConfig.realm + '/protocol/openid-connect/token';
+
+            try {
+
+                if (typeof keycloakObj == 'object' && Object.keys(keycloakObj).length != 0
+                    && Array.isArray(groupsIdsArr) && userToken.length > 0) {
+
+                    //Validate whether user in keycloakObj is same as user in userToken.
+                    const parseJwt = (userToken) => {
+                        try {
+                            return JSON.parse(Buffer.from(userToken.split('.')[1], 'base64').toString());
+                        } catch (er) {
+                            return null;
+                        }
+                    };
+
+                    let verifyToken = parseJwt(userToken);
+
+                    if (keycloakObj.username != verifyToken.preferred_username) {
+
+                        message = `The data provided in Keycloak Object as an Argument doesn't belong to current Logged-In user.`;
+
+                        resolve({
+                            "status": 401,
+                            "message": message
+                        });
+                    }
+
+                    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;
+                        let allUsers = [];
+                        let groupsData;
+
+                        config.method = 'get';
+                        delete config.data;
+                        delete config.url;
+                        config.headers.Authorization = 'Bearer ' + token;
+                        let clientRoles = await this.getUserInfoFromToken(keycloakObj.username, userToken);
+
+                        if (clientRoles.status) {
+                            resolve(clientRoles);
+                        }
+
+                        //admin case
+                        if ('realm-management' in clientRoles) {
+
+                            let URL2 = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/groups';
+                            config.url = URL2;
+
+                            try {
+
+                                let groups = await requestController.httpRequest(config, true);
+                                delete config.url
+
+                                groupsData = groups.data;
+
+
+                            } catch (er) {
+
+                                let error = await this.checkErrorType(er);
+                                reject(error);
+                            }
+
+                        } else {
+
+                            //agent case
+                            if ((keycloakObj.supervisedTeams).length == 0) {
+
+                                resolve([]);
+
+                                //supervisor case
+                            } else {
+
+                                //if no group ids are provided, send all the users of groups this user supervises.
+                                if (groupsIdsArr.length == 0) {
+
+                                    let supervisedGroups = keycloakObj.supervisedTeams;
+                                    groupsData = supervisedGroups;
+
+                                    //only send the users of provided groups.
+                                } else {
+
+                                    let groupsArr = [];
+                                    let idsArr = groupsIdsArr;
+
+                                    idsArr.forEach(id => {
+                                        let group = keycloakObj.supervisedTeams.find(group => {
+                                            return group.teamId == id;
+                                        });
+
+                                        if (!group) {
+
+                                            message = `Given User doesn't suprvise any group against id: ${id}`;
+
+                                            resolve({
+                                                "status": 404,
+                                                "message": message
+                                            });
+                                        }
+
+                                        groupsArr.push(group);
+                                    });
+
+                                    groupsData = groupsArr;
+                                }
+                            }
+                        }
+
+                        allUsers = await teamsService.getUsersOfGroups(groupsData, config, keycloakConfig);
+                        resolve(allUsers);
+
+                    } catch (er) {
+                        console.log(er);
+                        let error = await this.checkErrorType(er);
+                        console.log(error);
+                        reject(error);
+                    }
+
+
+                }
+
+                message = 'Please pass the valid arguments. First argument must be  (should not be empty object,' +
+                    'must contain valid key-value pair) and Second argument must be Array of groupIds (could be an empty array)' +
+                    '3rd Argument must be valid Access Token of current logged-in user.';
+
+                resolve({
+                    "status": 400,
+                    "message": message
+                });
+
+            } catch (er) {
+
+                let error = await this.checkErrorType(er);
+                reject(error);
+            };
+        });
+
+    }
+
     // this function requires comma separated list of roles in parameter e.g ["robot","human","customer"];
     getUsersByRole(keycloak_roles) {
         return new Promise(async (resolve, reject) => {
@@ -600,30 +943,30 @@ class KeycloakService extends Keycloak{
 
                             userObject.forEach((user) => {
 
-                                if(count > 0){
+                                if (count > 0) {
 
-                                   let userIndex = obj.findIndex(usr => {
+                                    let userIndex = obj.findIndex(usr => {
                                         return usr.username == user.username;
-                                   });
+                                    });
 
-                                   if(userIndex != -1){
+                                    if (userIndex != -1) {
                                         obj[userIndex].roles.push(keycloak_roles[i]);
                                         flag = false;
-                                   }
+                                    }
                                 }
-                                
-                                if(flag == true){
+
+                                if (flag == true) {
 
                                     obj.push({
                                         'id': user.id,
                                         'username': user.username,
-                                        'firstName': ((user.firstName == undefined)? "" : user.firstName),
-                                        'lastName': ((user.lastName == undefined)? "" : user.lastName),
+                                        'firstName': ((user.firstName == undefined) ? "" : user.firstName),
+                                        'lastName': ((user.lastName == undefined) ? "" : user.lastName),
                                         'roles': [keycloak_roles[i]]
-                                    }) 
+                                    })
 
                                 }
-    
+
                                 flag = true;
 
                             });
@@ -647,14 +990,14 @@ class KeycloakService extends Keycloak{
         });
     }
 
-    
-    async getRealmRoles(adminToken){
+
+    async getRealmRoles(adminToken) {
 
         return new Promise(async (resolve, reject) => {
-            
+
             let URL = `${keycloakConfig["auth-server-url"]}${keycloakConfig["USERNAME_ADMIN"]}/realms/${keycloakConfig["realm"]}/roles`;
 
-            
+
 
             let config = {
                 method: 'get',
@@ -680,12 +1023,12 @@ class KeycloakService extends Keycloak{
         });
     }
 
-    
-    
-    async assignRoleToUser(userId, roles, adminToken){
+
+
+    async assignRoleToUser(userId, roles, adminToken) {
 
         return new Promise(async (resolve, reject) => {
-            
+
             let URL = `${keycloakConfig["auth-server-url"]}${keycloakConfig["USERNAME_ADMIN"]}/realms/${keycloakConfig["realm"]}/users/${userId}/role-mappings/realm`;
 
             let config = {
@@ -713,14 +1056,14 @@ class KeycloakService extends Keycloak{
 
         });
     }
-    
 
-    async createUser(username,password,token,userRoles){
+
+    async createUser(username, password, token, userRoles) {
 
         let assignRole = [];
 
         return new Promise(async (resolve, reject) => {
-            
+
             let URL = `${keycloakConfig["auth-server-url"]}${keycloakConfig["USERNAME_ADMIN"]}/realms/${keycloakConfig["realm"]}/users`;
 
             let data = {
@@ -735,7 +1078,7 @@ class KeycloakService extends Keycloak{
                 ]
             }
 
-            
+
 
             let config = {
                 method: 'post',
@@ -751,22 +1094,22 @@ class KeycloakService extends Keycloak{
 
                 let tokenResponse = await requestController.httpRequest(config, false);
 
-                if(userRoles != []){
+                if (userRoles != []) {
                     //Get the user id at time of creation
                     let userLocation = tokenResponse.headers.location;
                     let userLocationSplit = userLocation.split("/");
                     let userId = userLocationSplit[(userLocationSplit.length) - 1];
 
-                    
+
                     //Get list of all the roles in keycloak realm
                     let realmRoles = await this.getRealmRoles(token);
-                    
+
                     //checking whether role exist in realmRoles object array:
-                    for(let role of realmRoles.data){
-                        
+                    for (let role of realmRoles.data) {
+
                         userRoles.forEach(userRole => {
 
-                            if(role.name == userRole.toLocaleLowerCase()){
+                            if (role.name == userRole.toLocaleLowerCase()) {
                                 assignRole.push({
                                     id: role.id,
                                     name: role.name
@@ -780,16 +1123,16 @@ class KeycloakService extends Keycloak{
                     let roleAssigned = await this.assignRoleToUser(userId, assignRole, token);
 
                     //Role assigned with status 
-                    if(roleAssigned.status == 204){
+                    if (roleAssigned.status == 204) {
                         resolve(tokenResponse);
                     }
 
-                }else{
+                } else {
 
                     resolve(tokenResponse);
 
                 }
-                 
+
 
             }
             catch (err) {
@@ -803,132 +1146,150 @@ class KeycloakService extends Keycloak{
     }
 
     //Authenticating Finesse User
-    async authenticateFinesse(username,password, finesseUrl, userRoles, finesseToken){
-        
+    async authenticateFinesse(username, password, finesseUrl, userRoles, finesseToken) {
+
         //Authentication of Finesse User, it returns a status code 200 if user found and 401 if unauthorized.
         let finesseLoginResponse;
 
-        if(finesseToken.length == 0){
-            finesseLoginResponse = await finesseService.authenticateUserViaFinesse(username,password,finesseUrl);
+        if (finesseToken.length == 0) {
+            finesseLoginResponse = await finesseService.authenticateUserViaFinesse(username, password, finesseUrl);
 
-        }else{
-            finesseLoginResponse = await finesseService.authenticateUserViaFinesseSSO(username,finesseToken,finesseUrl);
+        } else {
+            finesseLoginResponse = await finesseService.authenticateUserViaFinesseSSO(username, finesseToken, finesseUrl);
         }
 
         //If user is SSO then password is not provided, we are setting up a pre-defined password.
-        password = (password.length == 0)?"123456":password;
-        
+        password = (password.length == 0) ? "123456" : password;
+
         let authenticatedByKeycloak = false;
         let keycloakAuthToken = null;
         let timeoutErr = null;
 
-        if(finesseLoginResponse.status == 200){
-            try{
-                
+        if (finesseLoginResponse.status == 200) {
+            try {
+
                 //Checking whether finesse user already exist in keycloak and fetch its token
-                keycloakAuthToken = await this.getKeycloakTokenWithIntrospect(username,password,keycloakConfig["realm"]);
+                keycloakAuthToken = await this.getKeycloakTokenWithIntrospect(username, password, keycloakConfig["realm"]);
                 authenticatedByKeycloak = true;
-    
-            }catch(err){
 
-                if(err.response.status == 401){
+            } catch (err) {
+
+                if (err.response.status == 401) {
 
                     console.log("User doesn't exist in Keycloak, syncing finesse user in keycloak...");
 
-                }else{
+                } else {
 
-                    throw({
+                    throw ({
                         "status": err.response.status,
                         "message": err.response.data.error_description
                     });
 
                 }
 
-            }finally{
-
-                    //Finesse User not found in keycloak, so we are going to create one.
-                    if(!authenticatedByKeycloak){
+            } finally {
 
-                        try{
+                //Finesse User not found in keycloak, so we are going to create one.
+                if (!authenticatedByKeycloak) {
 
-                            //Fetching admin token, we pass it in our "Create User" API for authorization
-                            keycloakAuthToken = await this.getKeycloakTokenWithIntrospect(keycloakConfig["USERNAME_ADMIN"],keycloakConfig["PASSWORD_ADMIN"],keycloakConfig["realm"]);
-                        }catch(err){
+                    try {
 
-                            if(err.code == "ETIMEDOUT"){
+                        //Fetching admin token, we pass it in our "Create User" API for authorization
+                        keycloakAuthToken = await this.getKeycloakTokenWithIntrospect(keycloakConfig["USERNAME_ADMIN"], keycloakConfig["PASSWORD_ADMIN"], keycloakConfig["realm"]);
+                    } catch (err) {
 
-                                throw({
-                                    'Keycloak login status': 408,
-                                    'keycloak login message': `Keycloak server unaccessable against URL: ${keycloakConfig["auth-server-url"]}`
-                                });
+                        if (err.code == "ETIMEDOUT") {
 
-                            }else{
-                                throw({
-                                    "status": err.response.status,
-                                    "message": "Error While getting Keycloak admin token: "+ err.response.data.error_description
-                                });
-                            }
+                            throw ({
+                                'Keycloak login status': 408,
+                                'keycloak login message': `Keycloak server unaccessable against URL: ${keycloakConfig["auth-server-url"]}`
+                            });
 
+                        } else {
+                            throw ({
+                                "status": err.response.status,
+                                "message": "Error While getting Keycloak admin token: " + err.response.data.error_description
+                            });
                         }
 
-                        if(keycloakAuthToken.token){
+                    }
+
+                    if (keycloakAuthToken.token) {
 
-                            let token = keycloakAuthToken.token;
+                        let token = keycloakAuthToken.token;
 
-                            //validating customer Before Creation
-                            let {error, value} = validateUser({username, password, token, userRoles});
+                        //validating customer Before Creation
+                        let { error, value } = validateUser({ username, password, token, userRoles });
 
-                            if(error){
+                        if (error) {
 
-                                throw({
-                                    "status": 400,
-                                    "message": "Error while creation of user, error message: "+ error.details[0].message
-                                })
-                            }
+                            throw ({
+                                "status": 400,
+                                "message": "Error while creation of user, error message: " + error.details[0].message
+                            })
                         }
+                    }
 
-                        try{
-                            //Creating Finesse User inside keycloak.
-                            let userCreated = await this.createUser(username,password,keycloakAuthToken.token,userRoles);
-                            
-                            if(userCreated.status == 201){
+                    try {
+                        //Creating Finesse User inside keycloak.
+                        let userCreated = await this.createUser(username, password, keycloakAuthToken.token, userRoles);
 
-                                //Returning the token of recently created User 
-                                keycloakAuthToken = await this.getKeycloakTokenWithIntrospect(username,password,keycloakConfig["realm"]);
-                            }
-                                
+                        if (userCreated.status == 201) {
 
-                        }catch(err){
+                            //Returning the token of recently created User 
+                            keycloakAuthToken = await this.getKeycloakTokenWithIntrospect(username, password, keycloakConfig["realm"]);
+                        }
 
-                            if(err.code == "ETIMEDOUT"){
 
-                                throw({
-                                    'Keycloak login status': 408,
-                                    'keycloak login message': `Keycloak server unaccessable against URL: ${keycloakConfig["auth-server-url"]}`
-                                });
+                    } catch (err) {
 
-                            }else{
+                        if (err.code == "ETIMEDOUT") {
 
-                                console.log(err);
+                            throw ({
+                                'Keycloak login status': 408,
+                                'keycloak login message': `Keycloak server unaccessable against URL: ${keycloakConfig["auth-server-url"]}`
+                            });
 
-                                throw({
-                                    "status": err.response.status,
-                                    "message": "Error While creating Keycloak user: "+ err.response.data.error_description
-                                });
-                            }   
+                        } else {
+
+                            console.log(err);
+
+                            throw ({
+                                "status": err.response.status,
+                                "message": "Error While creating Keycloak user: " + err.response.data.error_description
+                            });
+                        }
                     }
                 }
             }
-    
+
             return keycloakAuthToken;
 
-        }else{
+        } else {
 
             return finesseLoginResponse
 
         }
     }
 
+    async checkErrorType(err) {
+
+        if (err.code == "ETIMEDOUT") {
+
+            return ({
+                'Keycloak login status': 408,
+                'keycloak login message': `Keycloak server unaccessable against URL: ${keycloakConfig["auth-server-url"]}`
+            });
+
+        } else {
+
+            return ({
+                "status": err.response.status,
+                "message": "Error: " + err.response.data.error_description
+            });
+        }
+    }
+
 }
 
 function validateUser(userData) {
@@ -938,7 +1299,7 @@ function validateUser(userData) {
         token: Joi.string().required(),
         userRoles: Joi.array().items(Joi.string()).allow(null)
     });
- 
+
     return schema.validate(userData);
 }
 

package/services/teamsService.js

@@ -0,0 +1,141 @@
+let requestController = require("../controller/requestController.js");
+
+class TeamsService {
+
+    constructor() {
+
+    }
+
+    //This function is being used inside getUserSupervisedGroups()
+    async getGroupByGroupID(groupId, username, token, keycloakConfig) {
+
+        return new Promise(async (resolve, reject) => {
+
+            try {
+
+                let URL = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/groups/' + groupId + '/';
+
+                var config = {
+                    method: 'get',
+                    url: URL,
+                    headers: {
+                        'Accept': 'application/json',
+                        'cache-control': 'no-cache',
+                        'Content-Type': 'application/x-www-form-urlencoded'
+                    },
+                    headers: {
+                        'Authorization': 'Bearer ' + token
+                    }
+                };
+
+                try {
+
+                    let groupAttributes = await requestController.httpRequest(config, false);
+                    let attributes = groupAttributes.data.attributes;
+
+                    if (attributes != null) {
+
+                        if ('supervisor' in attributes) {
+
+                            let supervisors = attributes['supervisor'][0].split(",");
+
+                            if (supervisors.includes(username)) {
+
+                                resolve({
+                                    'teamId': groupAttributes.data.id,
+                                    'teamName': groupAttributes.data.name
+                                });
+                            }
+                        }
+                    }
+
+                    resolve(null);
+
+                } catch (error) {
+                    reject(error);
+                }
+            } catch (er) {
+                reject("error" + er);
+            };
+        });
+    }
+
+    //this function is being used inside getTeamUsers()
+    async getUsersOfGroups(groups, config, keycloakConfig) {
+
+        return new Promise(async (resolve, reject) => {
+
+            try {
+                let allUsers = [];
+                let rolesArr = [];
+
+                if (groups.length > 0) {
+
+                    for (let group of groups) {
+
+                        let id = null;
+                        let name = null;
+
+                        if (typeof group === 'object') {
+                            id = (group.id) ? group.id : group.teamId;
+                            name = (group.name) ? group.name : group.teamName;
+                        }
+
+                        let URL = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/groups/' + id + '/members';
+                        config.url = URL;
+                        let users = await requestController.httpRequest(config, true);
+
+                        if (users.data.length > 0) {
+
+                            for (let user of users.data) {
+
+                                try {
+
+                                    let URL2 = keycloakConfig["auth-server-url"] + 'admin/realms/' + keycloakConfig.realm + '/users/' + user.id + '/role-mappings';
+                                    config.url = URL2;
+                                    let rolesObj = await requestController.httpRequest(config, true);
+
+                                    rolesArr = rolesObj.data.realmMappings.map(roles => {
+                                        return roles.name;
+                                    });
+
+                                } catch (er) {
+                                    reject(er);
+                                }
+
+                                let isExist = (allUsers).find(x => x.username == user.username);
+
+                                if (!isExist) {
+                                    allUsers.push({
+                                        'id': user.id,
+                                        'username': user.username,
+                                        'firstName': (user.firstName) ? user.firstName : '',
+                                        'lastName': (user.lastName) ? user.lastName : '',
+                                        'realm': keycloakConfig.realm,
+                                        'roles': rolesArr,
+                                        'team': {
+                                            'teamId': id,
+                                            'teamName': name
+                                        }
+                                    });
+                                }
+
+                            }
+
+                        }
+
+                    }
+
+                    resolve(allUsers);
+                }
+
+                resolve([]);
+
+            } catch (er) {
+                reject(er);
+            }
+        });
+    }
+}
+
+module.exports = TeamsService;