All files / node-activedirectory/lib/services/getUsersForGroup service.usersforgroup.chunkItem.js

26.19% Statements 11/42
0% Branches 0/17
0% Functions 0/11
26.83% Lines 11/41

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94    1x 1x 1x 1x 1x 1x 1x 1x 1x   1x                                                                                                                                                                 1x
 
 
const _                                 = require('underscore');
const parseDistinguishedName            = require('../internal/service.parseDistinguishedName');
const joinAttributes                    = require('../internal/service.joinAttributes');
const getRequiredLdapAttributesForUser  = require('../internal/service.getRequiredLdapAttributesForUser');
const search                            = require('../internal/service.search');
const pickAttributes                    = require('../internal/service.pickAttributes');
const User                              = require('../../models/user');
const limitpromises                     = require('limitpromises');
const maxPromiseConfig                  = require('../../configs/config.maxPromiseGroup');
 
const chunkItem = function(members, opts, self) {
    // We're going to build up a bulk LDAP query so we can reduce
    // the number of round trips to the server. We need to get
    // additional details about each 'member' to determine if
    // it is a group or another user. If it's a group, we need
    // to recursively retrieve the members of that group.
    let users = [];
    return new Promise((resolve, reject) => {
        var filter = _.reduce(members || [], function (memo, member, index) {
            return (memo + '(distinguishedName=' + parseDistinguishedName(member) + ')');
        }, '');
        filter = '(&(|(objectCategory=User)(objectCategory=Group))(|' + filter + '))';
        
        var localOpts = {
            filter: filter,
            scope: 'sub',
            attributes: joinAttributes((opts || {}).attributes || defaultAttributes.user || [],
                getRequiredLdapAttributesForUser(opts), ['groupType'])
        };
        // We need to limit the Searches. Too many of them will cause timeouts. the more calls the more performant
        // but the more risk you'll get timeout errors
        
        let searchResults = limitpromises(() => {
            return new Promise((resolve, reject) => {
                search.call(self, localOpts, function onSearch(err, members){
                    if(err){
                        return reject(err)
                    }
                    return resolve(members)
                });
            })
        }, [members], maxPromiseConfig.chunksItems, "members", {
            Reject : {
                rejectBehaviour : "retry",
                retryAttempts : 15
            },
            // Timeout : {
            //     timeoutBehaviour : "retry",
            //     timeoutMillis : 300,
            //     retryAttempts : 10
            // },
            // Reject : {
            //     rejectBehaviour : "none"
            // }
        });
        
 
 
        Promise.all(searchResults.map(res => {return res.result})).then(async Members =>{
            Members = Members[0];
            let nestedUsersArr = [];
            for(let i in Members){
                let member = Members[i];
                if(member){        
                    if(!member.groupType){
                        let user = new User(pickAttributes(member, (opts || {}).attributes || defaultAttributes.user));
                        self.emit(user);
                        users.push(user);                      
                    } else {
                        let nestedUsers = self.getUsersForGroup(opts, member.cn);
                        nestedUsersArr.push(nestedUsers);
                    }
                }
            }
            Promise.all(nestedUsersArr).then(AllNestedUsers => {
                for(let i in AllNestedUsers){
                    users = [].concat(users, AllNestedUsers[i]);
                }
                return resolve(users);
            }, err => {
                return reject(err)
            });
           
        }, err => {
            return reject(err);
        });
 
        
    });  
}
 
module.exports = chunkItem;