Available Model Methods (API)

Method Listing

addAttributeValue

Add a value into an array of attribute values:

$model->proxyaddresses = ['SMTP:sbauman@microsoft.com'];

$model->addAttributeValue('proxyaddresses', 'smtp:sbauman@local.com');

// Displays:
// [
//     'SMTP:sbauman@microsoft.com',
//     'smtp:sbauman@local.com'
// ]
var_dump($model->proxyaddresses);

addHidden

Add an attribute to hide when encoding a model using json_encode:

$model->addHidden('userpassword');

$model->addHidden(['userpassword', 'mail']);

// 'userpassword' and 'mail' will be omitted:
$attributes = json_encode($model);

addModification

Add a batch modification to the model to be executed upon save():

// Using an array...
$modification = [
    'attrib'  => 'telephoneNumber',
    'modtype' => LDAP_MODIFY_BATCH_ADD,
    'values'  => ['+1 555 555 1717'],
];

$model->addModification($modification);

// Using a BatchModification...
$mod = new \LdapRecord\Models\BatchModification(
    $attrib = 'telephoneNumber',
    $modType = LDAP_MODIFY_BATCH_ADD,
    $values = ['+1 555 555 1717']
);

$model->addModification($mod);

$model->save();

addVisible

Add an attribute to include that is being hidden when encoding a model using json_encode:

$model->addVisible('userpassword');

$model->addVisible(['userpassword', 'mail']);

ancestors

Begin querying the direct ancestors of the model:

$ancestors = $model->ancestors()->get();

asDateTime

Convert an LDAP timestamp to a Carbon\Carbon instance:

$carbon = $model->asDateTime('ldap', '20200508184557Z');

$carbon = $model->asDateTime('windows', '20200508184533.0Z');

$carbon = $model->asDateTime('windows-int', 132334371140000000);

attributesToArray

Convert all the models attributes to their JSON encodable value:

$attributes = $model->attributesToArray();

LDAP date attributes specified via the $dates model property will be converted in the returned array.

convert

Convert a model into another by copying its attributes, connection and distinguished name:

This will also set $model->exists property to true if the model being converted exists.

$into = new \LdapRecord\Models\ActiveDirectory\User();

// Returns instance of \LdapRecord\Models\ActiveDirectory\User
$user = $model->convert($into);

countAttributes

Get the total number of attributes on a model:

This does not count attribute values.

$model->fill([
    'cn' => 'Steve Bauman',
    'sn' => 'Bauman',
]);

// Returns '2'
$model->countAttributes();

createAttribute

Immediately inserts a new attribute value on the model.

Performs an ldap_mod_add under the hood.

This does not create attributes that do not exist on your LDAP schema for the object.

$model->createAttribute('telephonenumber', '+1 555 555 1717');

delete

Immediately delete an existing model instance:

$model->delete();

// Returns false.
$model->exists;

To delete nested objects contained in the model recursively, pass in true:

$model->delete($recursive = true);

deleteAttribute

Immediately delete an attribute on a model.

Performs an ldap_mod_del under the hood.

$model->deleteAttribute('telephonenumber');

$model->telephonenumber; // Returns null

descendants

Begin querying the direct descendants of the model:

$descendants = $model->descendants()->get();

escape

Prepare a value to be escaped:

// Returns \LdapRecord\Models\Attributes\EscapedValue;
$escapedValue = $model->escape($value, $ignore = '', $flags = 0);

// Cast to string for immediate return of escaped value:
$escapedValue = (string) $model->escape($value, $ignore = '', $flags = 0);

fill

Fill a model with attributes and values:

$model->fill([
    'cn' => 'Steve Bauman',
    'proxyAddresses' => ['foo', 'bar'],
]);

$model->save();

fresh

Get a fresh new instance of the existing model.

The model will be re-retrieved from the LDAP directory. The existing model will not be affected:

$fresh = $model->fresh();

fromDateTime

Convert a DateTime, Carbon or string to the specified LDAP timestamp type:

$date = new \DateTime('now');

$ldapTimestamp = $model->fromDateTime('ldap', $date);

$windowsTimestamp = $model->fromDateTime('windows', $date);

$windowsIntTimestamp = $model->fromDateTime('windows-int', $date);

getAnrAttributes

Get an array of ANR attributes defined on the model:

$attributes = $model->getAnrAttributes();

// Displays: [
//    'cn',
//    'sn',
//    'uid',
//    'name',
//    'mail',
//    'givenname',
//    'displayname'
// ]
var_dump($attributes);

getAttribute

Get the value of the specified attribute.

This will return an array if the attribute exists and null if non-existent:

If a mutator exists for the attribute (such as a date, or custom attribute mutator method), it's value will be returned instead.

// Returns array:
$values = $model->getAttribute('cn');

// Returns first value:
$value = $model->getAttribute('cn')[0];

// Returns null:
$null = $model->getAttribute('non-existent');

getAttributeValue

Performs the same as above.

getAttributes

Get all the models raw attributes:

Mutator attribute values will not be included in this array.

$attributes = $model->getAttributes();

foreach ($attributes as $attribute => $values) {
    //
}

getConnection

Resolve the underlying LdapRecord\Connection:

$connection = $model->getConnection();

$config = $connection->getConfiguration();

getConnectionName

Get the connection name from the model:

If no connection is set on the model, null will be returned.

class Entry extends Model
{
    protected $connection = 'domain-b';
}

// Returns 'domain-b'
$connectionName = (new Entry)->getConnectionName();

getConvertedGuid

Get the models string GUID:

// Example: bf9679e7-0de6-11d0-a285-00aa003049e2
$guid = $model->getConvertedGuid();

getCreatableDn

Get the models creatable Distinguished Name:

$model = new Entry(['cn' => 'John Doe']);

// Returns: 'cn=John Doe,dc=local,dc=com'
$creatableDn = $model->getCreatableDn();

$model->cn = 'Jane Doe';

// Returns: 'cn=Jane Doe,dc=local,dc=com'
$creatableDn = $model->getCreatableDn();

getCreatableRdn

Get the models creatable relative Distinguished Name:

$model = new Entry(['cn' => 'John Doe']);

// Returns: 'cn=John Doe'
$creatableDn = $model->getCreatableRdn();

$model->cn = 'Jane Doe';

// Returns: 'cn=Jane Doe'
$creatableDn = $model->getCreatableRdn();

getDateFormat

Get the format that dates are serialized to:

// Returns: 'Y-m-d\TH:i:sO'
$model->getDateFormat();

getDates

Get an array of attributes that should be mutated to dates:

$dates = $model->getDates();

// Displays: [
//    'createtimestamp' => 'ldap',
//    'modifytimestamp' => 'ldap',
// ]
var_dump($dates);

getDirty

Get the attributes that have been changed:

$model->cn = 'Changed';

foreach ($model->getDirty() as $attribute => $values) {
    // Displays: 'cn'
    echo $attribute;

    // Displays: ['Changed']
    var_dump($values);
}

getDn

Get the models Distinguished Name:

// Displays: 'cn=John Doe,dc=local,dc=com'
echo $model->getDn();

getFirstAttribute

Get the first value of an attribute:

$model->proxyaddresses = ['first', 'second'];

// Returns: 'first'
$value = $model->getFirstAttribute('proxyaddresses');

getGlobalScopes

Get the global scopes set on the model:

Model::addGlobalScope('my-scope', function () {
    // ...
});

// Returns: ['my-scope' => \Closure]
$scopes = $model->getGlobalScopes();

getGuidKey

Get the attribute key that contains the objects GUID:

// Returns: 'objectguid'
$model->getGuidKey();

getHidden

Get the hidden attributes for the model:

$model->addHidden('cn');

// Returns: ['cn']
$model->getHidden();

getModifications

Get the models batch modifications to be processed:

$model->cn = 'Changed';

// Returns:
// [
//      [
//      'attrib' => 'cn',
//      'modtype' => 1,
//      'values' => ['Changed'],
//     ]
// ]
$mods = $model->getModifications();

getName

Get the name of a model:

$model->setDn('cn=John Doe,dc=local,dc=com');

// Returns: 'John Doe'
$name = $model->getName();

getObjectGuid

Get the raw binary object GUID:

The raw binary object GUID will be returned when connecting to Active Directory.

The raw string GUID will be returned with other LDAP directories.

$rawBinary = $model->getObjectGuid();

getOriginal

Get the original, un-modified attributes on a model:

$model = Model::findBy('cn', 'Steve Bauman');

$model->cn = 'Changed';

// Returns:
// [
//    'cn' => ['Steve Bauman']
//    ...
// ]
$model->getOriginal();

getParentDn

Get the direct parent Distinguished Name of a model:

$model = Model::find('cn=John Doe,dc=local,dc=com');

// Returns: 'dc=local,dc=com'
$model->getParentDn();

// Returns: 'ou=Users,dc=local,dc=com'
$model->getParentDn('cn=Steve Bauman,ou=Users,dc=local,dc=com');

getRdn

Get the models Relative Distinguished Name:

$model = Model::find('cn=John Doe,dc=local,dc=com');

// Returns: 'cn=John Doe'
$model->getRdn();

// Returns: 'cn=Steve Bauman'
$model->getRdn('cn=Steve Bauman,ou=Users,dc=local,dc=com');

getVisible

Get the attributes that should be visible when encoding a model using json_encode:

$model->addVisible('cn', 'sn');

// Returns: ['cn', 'sn']
$visibleAttributes = $model->getVisible();

hasAttribute

Determine if the model has an attribute with a value:

$model = Model::findBy('cn', 'Steve Bauman');

// Returns: true
$modle->hasAttribute('cn');

// Returns: false
$model->hasAttribute('non-existent');

hasGetMutator

Determine if the model has a 'get' mutator for the given attribute:

class Entry extends Model
{
    public function getCnAttribute($values)
    {
        // ...
    }
}

$model = new Entry();

// Returns: true
$model->hasGetMutator('cn');

hasSetMutator

Determine if the model has a 'set' mutator for the given attribute:

class Entry extends Model
{
    public function setCnAttribute($values)
    {
        // ...
    }
}

$model = new Entry();

// Returns: true
$model->hasSetAttribute('cn');

inside

Set the container that the model should be created inside:

Calling inside() on an existing model will not perform any move / rename operation.

Use move or rename instead.

$model = new Model();

// ...

$model->inside('ou=Container,dc=local,dc=com');

$model->save();

is

Determine if a model is the same by comparing their Distinguished Names and connections:

// Returns: bool
$model->is($another);

isAncestorOf

Determine if a model is an ancestor of another:

$user = User::find('cn=John Doe,ou=Accounting,ou=Accounts,dc=acme,dc=org');
$ou = OrganizationalUnit::find('ou=Accounts,dc=acme,dc=org');

// Returns: true
$ou->isAncestorOf($user);

isChildOf

Determine if a model is an immediate child of another:

$ou = OrganizationalUnit::find('ou=Accounts,dc=acme,dc=org');
$user = User::find('cn=John Doe,ou=Accounts,dc=acme,dc=org');

// Returns: true
$user->isChildOf($ou);

isDateAttribute

Determine if given attribute is a date attribute on the model:

class Entry extends Model
{
    protected $dates = ['whenchanged' => 'windows'];
}

$model = new Entry();

// Returns: true
$model->isDateAttribute('whenchanged');

isDescendantOf

Determine if a model is a descendent of another:

$ou = OrganizationalUnit::find('ou=Accounts,dc=acme,dc=org');
$user = User::find('cn=John Doe,ou=Accounting,ou=Accounts,dc=acme,dc=org');

// Returns: true
$user->isDescendantOf($ou);

isDirty

Determine if the given attribute has been changed:

$model = Model::findBy('cn', 'Steve Bauman');

// Returns: false
$model->isDirty('cn');

$model->cn = 'Changed';

// Returns: true
$model->isDirty('cn');

isParentOf

Determine if a model is an immediate parent of another:

$ou = OrganizationalUnit::find('ou=Accounts,dc=acme,dc=org');
$user = User::find('cn=John Doe,ou=Accounts,dc=acme,dc=org');

// Returns: true
$ou->isParentOf($user);

makeHidden

Make the given, typically visible, attributes hidden on the model:

class Entry extends Model
{
    protected $visible = ['cn'];
}

// This will override the above:
$model->makeHidden('cn');

makeVisible

Make the given, typically hidden, attributes visible on the model:

class Entry extends Model
{
    protected $hidden = ['cn'];
}

// This will override the above:
$model->makeVisible('cn');

move

Move a model into the specified container:

$user = User::find('cn=Steve Bauman,dc=local,dc=com');

$ou = OrganizationalUnit::find('ou=Office Users,dc=local,dc=com');

$user->move($ou);

// Returns: 'cn=Steve Bauman,ou=Office Users,dc=local,d=com'
$user->getDn();

newBatchModification

Create a new LdapRecord\Models\BatchModification instance:

// Returns instance of: BatchModification
$mod = $model->newBatchModification(
    'cn', LDAP_MODIFY_BATCH_ADD, ['Steve Bauman']
);

newCollection

Create a new Tightenco\Collect\Support\Collection:

$collection = $model->newCollection($items = []);

newInstance

Create a new model instance:

$model = Model::findByAnr('sbauman');

$new = $model->newInstance();

newQuery

Create a new model query:

Global scopes and object classes will be applied to this query.

$results = $model->newQuery()->where('cn', 'contains', 'Steve')->get();

newQueryWithoutScopes

Create a new model query without global scopes:

Global scopes and object classes will not be applied to this query.

$results = $model->newQueryWithoutScopes()->get();

rename

Rename a model and keep it's container location:

When renaming is successful, the models distinguished name is automatically updated to reflect its new name in the directory, so you may run further operations on it during the same request.

$user = Model::find('cn=John Doe,dc=local,dc=com');

$user->rename('cn=Jane Doe');

// Returns: 'cn=Jane Doe,dc=local,dc=com'
$user->getDn();

save

Persist the new or existing model to the directory:

// Save a new model:
$model = new Model(['cn' => 'John Doe']);

$model->save();

// Updating an existing model:
$model = Model::findBy('cn', 'John Doe');

$model->cn = 'Jane Doe';

$model->save();

You may also pass an array of attributes to persist to your LDAP directory:

$model->save(['cn' => 'Steve Bauman']);

setAttribute

Set the value of an existing or non-existing attribute:

$model->setAttribute('attribute', 'value');

$model->setAttribute('attribute', ['foo', 'bar']);

setConnection

Set the name of the connection for the model to use:

$model = new Model();

// ...

$model->setConnection('domain-b');

// Model will be saved to 'domain-b'
$model->save();

setDateFormat

Set the date format to use when serializing LDAP dates:

$model = Model::findByAnr('sbauman');

$model->setDateFormat('Y-m-d H:i');

$attributes = json_encode($model);

setDn

Set the Distinguished Name of the model to be created with:

$model = new Model();

$model->setDn('cn=John Doe,dc=local,dc=com');

$model->save();

setFirstAttribute

Set the first value of an existing or non-existing attribute:

$model = new Model();

$model->setFirstAttribute('cn', 'John Doe');

// Returns ['cn' => ['John Doe']]
$model->getAttributes();

$model->proxyaddresses = ['foo', 'bar'];

// Overwrites 'foo' with 'baz':
$model->setFirstAttribute('proxyaddresses', ['baz']);

setHidden

Clear defined hidden attributes and set the attributes that should be hidden during serialization:

$model->setHidden(['cn', 'sn']);

// Attributes 'cn' and 'sn' will be removed:
$attributes = json_encode($model);

setModifications

Set the models batch modifications to be processed upon save:

$mods = [
    [
        'attrib'  => 'telephoneNumber',
        'modtype' => LDAP_MODIFY_BATCH_ADD,
        'values'  => ['+1 555 555 1717'],
    ]
];

$model->setModifications($mods);

$model->save();

setVisible

Clear defined visible attributes and set the attributes that should be visible during serialization:

$model->setVisible(['cn', 'sn']);

// Only attributes 'cn' and 'sn' will be included:
$attributes = json_encode($model);

siblings

Create a new query to retrieve a models siblings:

The existing model instance will be included in the query results.

$siblings = $model->siblings()->get();

synchronize

Refresh a models attributes by re-retrieving them from your LDAP directory.

This will affect the current model instance:

$model->synchronize();

update

Persist the changes of a model to the LDAP directory.

The save method should be used instead of update to persist new or existing models.

If the model does not exist in the directory, an exception will be thrown.

$model->cn = 'John Doe';

$model->update();

You may also provide an array of attributes to persist to your LDAP directory:

$model->update(['cn' => 'John Doe']);

updateAttribute

Immediately updates an attribute value on the model.

Performs an ldap_mod_replace under the hood.

$model->updateAttribute('proxyaddresses', ['foo', 'bar']);