node-ldapjs/lib/messages/search_entry.js

// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

const assert = require('assert-plus')
const util = require('util')

// var asn1 = require('asn1')

const LDAPMessage = require('./message')
const Attribute = require('../attribute')
const Protocol = require('../protocol')
const lassert = require('../assert')

/// --- Globals

// var BerWriter = asn1.BerWriter

/// --- API

function SearchEntry (options) {
  options = options || {}
  assert.object(options)
  lassert.optionalStringDN(options.objectName)

  options.protocolOp = Protocol.LDAP_REP_SEARCH_ENTRY
  LDAPMessage.call(this, options)

  this.objectName = options.objectName || null
  this.setAttributes(options.attributes || [])
}
util.inherits(SearchEntry, LDAPMessage)
Object.defineProperties(SearchEntry.prototype, {
  type: {
    get: function getType () { return 'SearchEntry' },
    configurable: false
  },
  _dn: {
    get: function getDN () { return this.objectName },
    configurable: false
  },
  object: {
    get: function getObject () {
      const obj = {
        dn: this.dn.toString(),
        controls: []
      }
      this.attributes.forEach(function (a) {
        if (a.vals && a.vals.length) {
          if (a.vals.length > 1) {
            obj[a.type] = a.vals.slice()
          } else {
            obj[a.type] = a.vals[0]
          }
        } else {
          obj[a.type] = []
        }
      })
      this.controls.forEach(function (element) {
        obj.controls.push(element.json)
      })
      return obj
    },
    configurable: false
  },
  raw: {
    get: function getRaw () {
      const obj = {
        dn: this.dn.toString(),
        controls: []
      }

      this.attributes.forEach(function (a) {
        if (a.buffers && a.buffers.length) {
          if (a.buffers.length > 1) {
            obj[a.type] = a.buffers.slice()
          } else {
            obj[a.type] = a.buffers[0]
          }
        } else {
          obj[a.type] = []
        }
      })
      this.controls.forEach(function (element) {
        obj.controls.push(element.json)
      })
      return obj
    },
    configurable: false
  }
})

SearchEntry.prototype.addAttribute = function (attr) {
  if (!attr || typeof (attr) !== 'object') { throw new TypeError('attr (attribute) required') }

  this.attributes.push(attr)
}

SearchEntry.prototype.toObject = function () {
  return this.object
}

SearchEntry.prototype.fromObject = function (obj) {
  if (typeof (obj) !== 'object') { throw new TypeError('object required') }

  const self = this
  if (obj.controls) { this.controls = obj.controls }

  if (obj.attributes) { obj = obj.attributes }
  this.attributes = []

  Object.keys(obj).forEach(function (k) {
    self.attributes.push(new Attribute({ type: k, vals: obj[k] }))
  })

  return true
}

SearchEntry.prototype.setAttributes = function (obj) {
  if (typeof (obj) !== 'object') { throw new TypeError('object required') }

  if (Array.isArray(obj)) {
    obj.forEach(function (a) {
      if (!Attribute.isAttribute(a)) { throw new TypeError('entry must be an Array of Attributes') }
    })
    this.attributes = obj
  } else {
    const self = this

    self.attributes = []
    Object.keys(obj).forEach(function (k) {
      const attr = new Attribute({ type: k })
      if (Array.isArray(obj[k])) {
        obj[k].forEach(function (v) {
          attr.addValue(v.toString())
        })
      } else {
        attr.addValue(obj[k].toString())
      }
      self.attributes.push(attr)
    })
  }
}

SearchEntry.prototype._json = function (j) {
  assert.ok(j)

  j.objectName = this.objectName.toString()
  j.attributes = []
  this.attributes.forEach(function (a) {
    j.attributes.push(a.json || a)
  })

  return j
}

SearchEntry.prototype._parse = function (ber) {
  assert.ok(ber)

  this.objectName = ber.readString()
  assert.ok(ber.readSequence())

  const end = ber.offset + ber.length
  while (ber.offset < end) {
    const a = new Attribute()
    a.parse(ber)
    this.attributes.push(a)
  }

  return true
}

SearchEntry.prototype._toBer = function (ber) {
  assert.ok(ber)

  const formattedObjectName = this.objectName.format({ skipSpace: true })
  ber.writeString(formattedObjectName)
  ber.startSequence()
  this.attributes.forEach(function (a) {
    // This may or may not be an attribute
    ber = Attribute.toBer(a, ber)
  })
  ber.endSequence()

  return ber
}

/// --- Exports

module.exports = SearchEntry