Javascript 承诺使用ldapjs_Javascript_Node.js_Promise_Ldapjs

Javascript 承诺使用ldapjs

javascript node.js

Javascript 承诺使用ldapjs,javascript,node.js,promise,ldapjs,Javascript,Node.js,Promise,Ldapjs,我想将以下代码转换为使用promise。它正在工作并在active directory中输出用户的属性 var client = ldap.createClient({ url: ldap_url }); client.bind(ldap_username, ldap_password, function (err) { client.search(ldap_dn_search, opts, function (err, search) { search.on('s

我想将以下代码转换为使用promise。它正在工作并在active directory中输出用户的属性

var client = ldap.createClient({
  url: ldap_url
});

client.bind(ldap_username, ldap_password, function (err) {
    client.search(ldap_dn_search, opts, function (err, search) {
        search.on('searchEntry', function (entry) {
          var user = entry.object;
          // It is working!!!. It outputs all user attributes.
          console.log(user);
        });

    });
});

下面是我的尝试，但它没有输出任何内容

var Promise = require('promise');
var client_bind = Promise.denodeify(client.bind);
var client_search = Promise.denodeify(client.search);

client_bind(ldap_username, ldap_password)
.then(function(err){
  client_search(ldap_dn_search, opts)
    .then(function(search){
      var search_on = Promise.denodeify(search.on);
      search_on('searchEntry')
        .then(function(entry){
          var user = entry.object;

          // It doesn't output anything !!!
          console.log(user);
        });
      });

    });

最有可能的是，这些方法确实需要作为上下文在

客户机上调用，因此在将它们传递给Promise之前，您需要对它们进行定义。取消定义：
var client_bind = Promise.denodeify(client.bind.bind(client));
var client_search = Promise.denodeify(client.search.bind(client));

此外，正确使用承诺应该是这样的：
client_bind(ldap_username, ldap_password).then(function() {
    return client_search(ldap_dn_search, opts);
//  ^^^^^^ always return something from the callback
}).then(function(search) { // flatten your chain
    return Promise.denodeify(search.on).call(search, 'searchEntry');
//                                    ^^^^^^ an alternative to `bind`
}).then(function(entry){
    var user = entry.object;
    console.log(user);
}).catch(function(err) { // always catch errors!
    console.error(err);
});

最有可能的是，这些方法确实需要作为上下文在客户机上调用，因此在将它们传递给Promise之前，您需要对它们进行定义。取消定义：
var client_bind = Promise.denodeify(client.bind.bind(client));
var client_search = Promise.denodeify(client.search.bind(client));

此外，正确使用承诺应该是这样的：
client_bind(ldap_username, ldap_password).then(function() {
    return client_search(ldap_dn_search, opts);
//  ^^^^^^ always return something from the callback
}).then(function(search) { // flatten your chain
    return Promise.denodeify(search.on).call(search, 'searchEntry');
//                                    ^^^^^^ an alternative to `bind`
}).then(function(entry){
    var user = entry.object;
    console.log(user);
}).catch(function(err) { // always catch errors!
    console.error(err);
});

使用Bluebird Promises，简单的方法是正常创建客户机，然后在客户机上运行promisifyAll（）
var ldap = require('ldapjs');
var Promise = require('bluebird');

var client = ldap.createClient({
  url: 'ldap://my-server:1234',
});

Promise.promisifyAll(client);

现在可以调用client.addAsync（）和client.searchAsync（）等
client.bindAsync(secUserDn, secUserPassword)
  .then(doSearch) // if it works, call doSearch
  .catch(function (err) { // if bind fails, handle it
    console.error('Error on bind', err)
  });

function doSearch(data) {
  client.searchAsync('CN=A Test,OU=Users,DC=website,DC=com', options)
    .then(function (data) { // Handle the search result processing
      console.log('I got a result');
    })  
    .catch(function (err) { // Catch potential errors and handle them
      console.error('Error on search', err);
    });
}

使用Bluebird Promises，简单的方法是正常创建客户机，然后在客户机上运行promisifyAll（）
var ldap = require('ldapjs');
var Promise = require('bluebird');

var client = ldap.createClient({
  url: 'ldap://my-server:1234',
});

Promise.promisifyAll(client);

现在可以调用client.addAsync（）和client.searchAsync（）等
client.bindAsync(secUserDn, secUserPassword)
  .then(doSearch) // if it works, call doSearch
  .catch(function (err) { // if bind fails, handle it
    console.error('Error on bind', err)
  });

function doSearch(data) {
  client.searchAsync('CN=A Test,OU=Users,DC=website,DC=com', options)
    .then(function (data) { // Handle the search result processing
      console.log('I got a result');
    })  
    .catch(function (err) { // Catch potential errors and handle them
      console.error('Error on search', err);
    });
}

我也有同样的问题。
搜索会发出事件，所以我们需要一些东西来处理它们，并沿着链进一步传递。
下面是一段代码，对我很有用：
var ldap = require('ldapjs');
var promise = require('bluebird');

var client = ldap.createClient({url: app.settings['ldap']['server']});
var uid;

promise.promisifyAll(client);

function searchPromise(res, notfoundtext) {
  return new Promise(function(resolve, reject) {
    var found = false;
    res.on('searchEntry', function(entry) {
      found = true;
      resolve(entry);
    });
    res.on('error', function(e) {
      reject(e.message);
    });
    res.on('end', function() {
      if (!found) {
        reject(notfoundtext);
      }
    });
  });
}

client.searchAsync(app.settings['ldap']['baseDn'], {filter: '(mail='+credentials.email+')', scope: 'sub'})
  .then(function(res) {
    return searchPromise(res, 'User isn\'t exists.');
  })
  .then(function (entry) {
    uid = entry.object.uid;
    return client.bindAsync(entry.object.dn, credentials.password);
  })
  .then(function() {
    return client.searchAsync('cn='+app.settings['ldap']['group']+',cn=groups,'+app.settings['ldap']['baseDn'], {scope: 'sub', filter: '(memberUid='+uid+')'});
  })
  .then(function(res) {
    return searchPromise(res, 'User is not in group ' + app.settings['ldap']['group']);
  })
  .then(function() {
    console.log('All is ok');
  })
  .catch(function(message) {
    console.log('Error:' + message);
  });

在搜索之后，我立即添加了另一个步骤来捕获事件，处理它们，并沿着链进一步传递它。这使得这个功能很有希望
祝你好运（编码）我也有同样的问题。
搜索会发出事件，所以我们需要一些东西来处理它们，并沿着链进一步传递。
下面是一段代码，对我很有用：
var ldap = require('ldapjs');
var promise = require('bluebird');

var client = ldap.createClient({url: app.settings['ldap']['server']});
var uid;

promise.promisifyAll(client);

function searchPromise(res, notfoundtext) {
  return new Promise(function(resolve, reject) {
    var found = false;
    res.on('searchEntry', function(entry) {
      found = true;
      resolve(entry);
    });
    res.on('error', function(e) {
      reject(e.message);
    });
    res.on('end', function() {
      if (!found) {
        reject(notfoundtext);
      }
    });
  });
}

client.searchAsync(app.settings['ldap']['baseDn'], {filter: '(mail='+credentials.email+')', scope: 'sub'})
  .then(function(res) {
    return searchPromise(res, 'User isn\'t exists.');
  })
  .then(function (entry) {
    uid = entry.object.uid;
    return client.bindAsync(entry.object.dn, credentials.password);
  })
  .then(function() {
    return client.searchAsync('cn='+app.settings['ldap']['group']+',cn=groups,'+app.settings['ldap']['baseDn'], {scope: 'sub', filter: '(memberUid='+uid+')'});
  })
  .then(function(res) {
    return searchPromise(res, 'User is not in group ' + app.settings['ldap']['group']);
  })
  .then(function() {
    console.log('All is ok');
  })
  .catch(function(message) {
    console.log('Error:' + message);
  });

在搜索之后，我立即添加了另一个步骤来捕获事件，处理它们，并沿着链进一步传递它。这使得这个功能很有希望
祝你好运编码）
我在这里遇到了同样的问题，但我通过添加承诺和解决响应而不使用蓝鸟，这是我代码的一个示例：
async getLdapUser(username: any): Promise<any> {
    let myPromise = new Promise<boolean>((resolve, reject) => {
      console.log('ssssssssss', username);
      const adSuffix = 'OU=xxxx,OU=xxxxx,DC=xxxxxxx,DC=xxxxxx'; 
      const password = 'xxxxxxxxxxxxx';
      // Create client and bind to AD
      const client = ldap.createClient({
        url: 'ldap://1.1.1.1:389',
      });
      // promise.promisifyAll(client);
      let resp = false;
      // console.log(client);
      client.bind('userTest', password,(err: any) => {
        console.log('RESP', resp);
        if (err) {
          console.log('Error in new connetion ' + err);
        } else {
          /*if connection is success then go for any operation*/
          console.log('Success');
          const searchOptions: {} = {
            scope: 'sub',
            filter: '(sAMAccountName=' + username + ')',
            attributes: ['sAMAccountName'],
          };

          client.search(adSuffix, searchOptions, (err: any, res: any) => {
            assert.ifError(err);
            res.on('searchEntry', (entry: any) => {
              resp = true;

            });
            res.on('error', (error: any) => {
              console.log('err');
              reject(error.message);
            });

            await res.on('end', (result: any) => {
              resolve(resp);

            });
          });
        }
      });
    });
    return myPromise;

  }

异步getLdapUser（用户名：any）：承诺{
让我的承诺=新的承诺（（解决，拒绝）=>{
日志（'ssss'，用户名）；
常量adSuffix='OU=xxxx，OU=xxxxx，DC=xxxxxxx，DC=xxxxxx'；
常量密码='XXXXXXXXXXXX'；
//创建客户端并绑定到AD
const client=ldap.createClient({
网址：'ldap://1.1.1.1:389',
});
//承诺、承诺（客户）；
设resp=false；
//console.log（客户端）；
client.bind（'userTest'，密码，（err:any）=>{
控制台日志（'RESP'，RESP）；
如果（错误）{
log（'新连接中的错误'+err）；
}否则{
/*如果连接成功，则进行任何操作*/
console.log（'Success'）；
常量搜索选项：{}={
范围：'子'，
筛选器：'（sAMAccountName='+用户名+）'，
属性：['sAMAccountName']，
};
search（adSuffix，searchOptions，（err:any，res:any）=>{
assert.ifError（err）；
res.on（'searchEntry'，（条目：任意）=>{
resp=真；
});
res.on（'error'，（error:any）=>{
console.log（'err'）；
拒绝（错误消息）；
});
等待res.on（'结束'，（结果：任意）=>{
解决（resp）；
});
});
}
});
});
回报我的承诺；
}
我在这里遇到了同样的问题，但我通过添加承诺和解决响应来解决它，而不使用蓝鸟，这是我代码的一个示例：
async getLdapUser(username: any): Promise<any> {
    let myPromise = new Promise<boolean>((resolve, reject) => {
      console.log('ssssssssss', username);
      const adSuffix = 'OU=xxxx,OU=xxxxx,DC=xxxxxxx,DC=xxxxxx'; 
      const password = 'xxxxxxxxxxxxx';
      // Create client and bind to AD
      const client = ldap.createClient({
        url: 'ldap://1.1.1.1:389',
      });
      // promise.promisifyAll(client);
      let resp = false;
      // console.log(client);
      client.bind('userTest', password,(err: any) => {
        console.log('RESP', resp);
        if (err) {
          console.log('Error in new connetion ' + err);
        } else {
          /*if connection is success then go for any operation*/
          console.log('Success');
          const searchOptions: {} = {
            scope: 'sub',
            filter: '(sAMAccountName=' + username + ')',
            attributes: ['sAMAccountName'],
          };

          client.search(adSuffix, searchOptions, (err: any, res: any) => {
            assert.ifError(err);
            res.on('searchEntry', (entry: any) => {
              resp = true;

            });
            res.on('error', (error: any) => {
              console.log('err');
              reject(error.message);
            });

            await res.on('end', (result: any) => {
              resolve(resp);

            });
          });
        }
      });
    });
    return myPromise;

  }

异步getLdapUser（用户名：any）：承诺{
让我的承诺=新的承诺（（解决，拒绝）=>{
日志（'ssss'，用户名）；
常量adSuffix='OU=xxxx，OU=xxxxx，DC=xxxxxxx，DC=xxxxxx'；
常量密码='XXXXXXXXXXXX'；
//创建客户端并绑定到AD
const client=ldap.createClient({
网址：'ldap://1.1.1.1:389',
});
//承诺、承诺（客户）；
设resp=false；
//console.log（客户端）；
client.bind（'userTest'，密码，（err:any）=>{
控制台日志（'RESP'，RESP）；
如果（错误）{
log（'新连接中的错误'+err）；
}否则{
/*如果连接成功，则进行任何操作*/
console.log（'Success'）；
常量搜索选项：{}={
范围：'子'，
筛选器：'（sAMAccountName='+用户名+）'，
属性：['sAMAccountName']，
};
search（adSuffix，searchOptions，（err:any，res:any）=>{
assert.ifError（err）；
res.on（'searchEntry'，（条目：任意）=>{
resp=真；
});
res.on（'error'，（error:any）=>{
console.log（'err'）；
拒绝（错误消息）；
});
等待res.on（'结束'，（结果：任意）=>{
解决（resp）；
});
});
}
});
});
回报我的承诺；
}
我使用了您提供的代码。我遇到错误：无法验证叶签名，即使我有process.env['NODE\u TLS\u REJECT\u UNAUTHORIZED']='0'；在我剧本的最顶端。这似乎不是承诺的问题，是吗？我不确定。如果我将其切换回原始代码，它将使用process.env['NODE\u TLS\u REJECT\u UNAUTHORIZED']='0'；如果将代码更改为：“return Promise.denodeify（search.on）.call（search，'searchEntry'）；”以返回“某物”；异常停止。我使用了您提供的代码。我遇到错误：无法验证叶签名，即使我有process.env['NODE\u TLS\u REJECT\u UNAUTHORIZED']='0'；在我剧本的最顶端。这似乎不是承诺的问题，是吗？我不确定。如果我将其切换回原始代码，它将使用process.env['NODE\u TLS\u REJECT\u UNAUTHORIZED']='0'；如果查