# There is a basic way to work with it
from lib389.idm.user import UserAccounts
users = UserAccounts(standalone, DEFAULT_SUFFIX)
user_properties = {
       'uid': USER_NAME,
       'cn' : USER_NAME,
       'sn' : USER_NAME,
       'userpassword' : USER_PWD,
       'uidNumber' : '1000',
       'gidNumber' : '2000',1
       'homeDirectory' : '/home/{}'.format(USER_NAME)
        }
testuser = users.create(properties=user_properties)

# After this you can:
# Get the list of them
users.list()

# Get some user:
testuser = users.get('testuser')
# or
testuser = users.list()[0] # You can loop through 'for user in users:'

# Set some attribute to the entry
testuser.set('userPassword', 'password')

# Bind as the user
conn = testuser.bind('password') # It will create a new connection
conn.modify_s()
conn.unbind_s()

# Delete
testuser.delete()

# Group and Groups additionaly have 'is_member', 'add_member' and 'remove_member' methods
# PosixGroup and PosixGroups have 'check_member' and 'add_member'
from lib389.idm.group import Groups
from lib389.idm.posixgroup import PosixGroups

groups = Groups(standalone, DEFAULT_SUFFIX)
posix_groups = PosixGroups(standalone, DEFAULT_SUFFIX)
group_properties = {
       'cn' : 'group1',
       'description' : 'testgroup'
       }
group = groups.create(properties=group_properties)

# So now you can:
# Check the membership - shouldn't we make it consistent?
assert(not group.is_member(testuser.dn))
assert(not posix_groups.check_member(testuser.dn))

group.add_member(testuser.dn)
posix_groups.add_member(testuser.dn)

# Remove member - add the method to PosixGroups too?
group.remove_member(testuser.dn)

group.delete()

# Don't forget that Services requires created rdn='ou=Services'
# This you can create with OrganisationalUnits
 
from lib389.idm.organisationalunit import OrganisationalUnits
from lib389.idm.services import ServiceAccounts
 
ous = OrganisationalUnits(standalone, DEFAULT_SUFFIX)
services = ServiceAccounts(standalone, DEFAULT_SUFFIX)

# Create the OU for them
ous.create(properties={
        'ou': 'Services',
        'description': 'Computer Service accounts which request DS bind',
    })

# Now, we can create the services from here.
service = services.create(properties={
    'cn': 'testbind',
    'userPassword': 'Password1'
    })

conn = service.bind('Password1')
conn.unbind_s()

from lib389.index import Indexes
 
indexes = Indexes(standalone)
 
# create and delete a default index.
index = indexes.create(properties={
    'cn': 'modifytimestamp',
    'nsSystemIndex': 'false',
    'nsIndexType': 'eq'
    })

default_index_list = indexes.list()
found = False
for i in default_index_list:
    if i.dn.startswith('cn=modifytimestamp'):
        found = True
assert found
index.delete()

default_index_list = indexes.list()
found = False
for i in default_index_list:
    if i.dn.startswith('cn=modifytimestamp'):
        found = True
assert not found

from lib389.tasks import Task
 
newtask = Task(instance, dn) # Should we create Tasks and put the precious to TasksLegacy?

newtask.create(rdn, properties, basedn)
 
# Check if the task is complete
assert(newtask.is_complete())

# Check task's exit code if task is complete, else None
if newtask.is_complete():
    exit_code = newtask.get_exit_code()

# Wait until task is complete
newtask.wait()
 
# If True,  waits for the completion of the task before to return
args = {TASK_WAIT: True}
 
# Some tasks ca be found only under old object. You can access them with this:
standalone.tasks.importLDIF(DEFAULT_SUFFIX, path_ro_ldif, args)
standalone.tasks.exportLDIF(DEFAULT_SUFFIX, benamebase=None, output_file=path_to_ldif, args)
standalone.tasks.db2bak(backup_dir, args)
standalone.tasks.bak2db(bename=None, backup_dir, args)
standalone.tasks.reindex(suffix=None, benamebase=None, attrname=None, args)
standalone.tasks.fixupMemberOf(suffix=None, benamebase=None, filt=None, args)
standalone.tasks.fixupTombstones(bename=None, args)
standalone.tasks.automemberRebuild(suffix=DEFAULT_SUFFIX, scope='sub', filterstr='objectclass=top', args)
standalone.tasks.automemberExport(suffix=DEFAULT_SUFFIX, scope='sub', fstr='objectclass=top', ldif_out=None, args)
standalone.tasks.automemberMap(ldif_in=None, ldif_out=None, args)
standalone.tasks.fixupLinkedAttrs(linkdn=None, args)
standalone.tasks.schemaReload(schemadir=None, args)
standalone.tasks.fixupWinsyncMembers(suffix=DEFAULT_SUFFIX, fstr='objectclass=top', args)
standalone.tasks.syntaxValidate(suffix=DEFAULT_SUFFIX, fstr='objectclass=top', args)
standalone.tasks.usnTombstoneCleanup(suffix=DEFAULT_SUFFIX, bename=None, maxusn_to_delete=None, args)
standalone.tasks.sysconfigReload(configfile=None, logchanges=None, args)
standalone.tasks.cleanAllRUV(suffix=None, replicaid=None, force=None, args)
standalone.tasks.abortCleanAllRUV(suffix=None, replicaid=None, certify=None, args)
standalone.tasks.upgradeDB(nsArchiveDir=None, nsDatabaseType=None, nsForceToReindex=None, args)

# Plugin and Plugins additionaly have 'enable', 'disable' and 'status' methods
# Here I show you basic way to work with it. Additional methods of complex plugins will be described in subchapters
 
from lib389.plugin import Plugins, ACLPlugin
from lib389._constants import PLUGIN_ACL
 
# You can just enable/disable plugins from Plugins interface
plugins = Plugins(standalone)
plugins.enable(PLUGIN_ACL) 
 
# Or you can first 'get' it and then work with it (make sense if your plugin is a complex one)
aclplugin = ACLPlugin(standalone)

aclplugin.enable()

aclplugin.disable()

# True if nsslapd-pluginEnabled is 'on', False otherwise - change the name?
assert(uniqplugin.status())

from lib389.plugin import MemberOfPlugin
 
memberofplugin = MemberOfPlugin(standalone)

# Create fixup task and return the object
memberof_task = memberofplugin.fixup(basedn, _filter=None)

from lib389.plugin import USNPlugin
 
usnplugin = USNPlugin(standalone)

# Check if global mode is set
assert(usnplugin.is_global_mode_set())
 
# Set 'nsslapd-entryusn-global' to 'on'
usnplugin.enable_global_mode()

# Set 'nsslapd-entryusn-global' to 'off'
usnplugin.disable_global_mode()

# Create USN tombstone cleanup task and return the object
# Optionaly you can specify 'suffix', 'backend' and 'maxusn_to_delete'
# It is mandatory to specify either 'suffix' or 'backend'
usnplugin.cleanup(suffix=None, backend=None, max_usn=None)

# Get attribute values of 'supportedSASLMechanisms'
standalone.rootdse.supported_sasl()

# Returns True or False
assert(standalone.rootdse.supports_sasl_gssapi()
assert(standalone.rootdse.supports_sasl_ldapssotoken()
assert(standalone.rootdse.supports_sasl_plain()
assert(standalone.rootdse.supports_sasl_external()
assert(standalone.rootdse.supports_exop_whoami()
assert(standalone.rootdse.supports_exop_ldapssotoken_request()
assert(standalone.rootdse.supports_exop_ldapssotoken_revoke()

# Set config attribute:
standalone.config.set('passwordStorageScheme', 'SSHA')
 
# Reset config attribute (by deleting it):
standalone.config.reset('passwordStorageScheme')

# Enable/disable logs (error, access, audit):
standalone.config.enable_log('error')
standalone.config.disable_log('access')

# Set loglevel for errors log.
# If 'update' set to True, it will add the 'vals' to existing values in the loglevel attribute 
standalone.config.loglevel(vals=(LOG_DEFAULT,), service='error', update=False)
# You can get log levels from lib389._constants
(LOG_TRACE,
 LOG_TRACE_PACKETS,
 LOG_TRACE_HEAVY,
 LOG_CONNECT,
 LOG_PACKET,
 LOG_SEARCH_FILTER,
 LOG_CONFIG_PARSER,
 LOG_ACL,
 LOG_ENTRY_PARSER,
 LOG_HOUSEKEEPING,
 LOG_REPLICA,
 LOG_DEFAULT,
 LOG_CACHE,
 LOG_PLUGIN,
 LOG_MICROSECONDS,
 LOG_ACL_SUMMARY) = [1 << x for x in (list(range(8)) + list(range(11, 19)))]
 
# Set 'nsslapd-accesslog-logbuffering' to 'on' if True, otherwise set it to 'off'
standalone.config.logbuffering(True)

from lib389.dseldif import DSEldif
 
dse_ldif = DSEldif(topo.standalone)
 
# Get a list of attribute values under a given entry
config_cn = dse_ldif.get(DN_CONFIG, 'cn')
 
# Add an attribute under a given entry
dse_ldif.add(DN_CONFIG, 'someattr', 'someattr_value')
 
# Replace attribute values with a new one under a given entry. It will remove all previous 'someattr' values
dse_ldif.replace(DN_CONFIG, 'someattr', 'someattr_value')

# Delete attributes under a given entry
dse_ldif.delete(DN_CONFIG, 'someattr')
dse_ldif.delete(DN_CONFIG, 'someattr', 'someattr_value')

# Creates users as user<min through max>. Password will be set to password<number>
# This will automatically work with the bind loadtest.
# Template
# objectClass: top
# objectclass: person
# objectClass: organizationalPerson
# objectClass: inetorgperson
# objectClass: posixAccount
# objectClass: shadowAccount
# sn: user[A]
# cn: user[A]
# givenName: user[A]
# description: description [A]
# userPassword: user[A]
# mail: user[A]@example.com
# uidNumber: 1[A]
# gidNumber: 2[A]
# shadowMin: 0
# shadowMax: 99999
# shadowInactive: 30
# shadowWarning: 7
# homeDirectory: /home/user[A]
# loginShell: /bin/false
topology.instance.ldclt.create_users('ou=People,{}'.format(DEFAULT_SUFFIX), max=1999)

# Run the load test for a few rounds
topology.instance.ldclt.bind_loadtest('ou=People,{}'.format(DEFAULT_SUFFIX), max=1999)

from lib389.passwd import password_hash, password_generate
 
bindir = standalone.ds_paths.bin_dir
PWSCHEMES = [
    'SHA1',
    'SHA256',
    'SHA512',
    'SSHA',
    'SSHA256',
    'SSHA512',
    'PBKDF2_SHA256',
]
 
# Generate password
raw_secure_password = password_generate()
 
# Encrypt the password
# default scheme is 'SSHA512'
secure_password = password_hash(raw_secure_password, scheme='SSHA256', bin_dir=bindir)

# You can get any variable from the list bellow. Like this:
product = standalone.ds_paths.product
 
variables = [
    'product',
    'version',
    'user',
    'group',
    'root_dn',
    'prefix',
    'bin_dir',
    'sbin_dir',
    'lib_dir',
    'data_dir',
    'tmp_dir',
    'sysconf_dir',
    'config_dir',
    'schema_dir',
    'cert_dir',
    'local_state_dir',
    'run_dir',
    'lock_dir',
    'log_dir',
    'inst_dir',
    'db_dir',
    'backup_dir',
    'ldif_dir',
    'initconfig_dir',
]

# Get the schema as an LDAP entry
schema = standalone.schema.get_entry()
 
# Get the schema as a python-ldap SubSchema object
subschema = standalone.schema.get_subschema()
 
# Get a list of the schema files in the instance schemadir
schema_files = standalone.schema.list_files()


# Convert the given schema file name to its python-ldap format suitable for passing to ldap.schema.SubSchema()
parsed = standalone.schema.file_to_ldap('/full/path/to/file.ldif')
 
# Convert the given schema file name to its python-ldap format ldap.schema.SubSchema object
parsed = standalone.schema.file_to_subschema('/full/path/to/file.ldif')
 
# Add a schema element to the schema
standalone.schema.add_schema(attr, val)
 
# Delete a schema element from the schema
standalone.schema.del_schema(attr, val)
 
# Add 'attributeTypes' definition to the schema 
standalone.schema.add_attribute(attributes)

# Add 'objectClasses' definition to the schema
standalone.schema.add_objectclass(objectclasses)

# Get a schema nsSchemaCSN attribute
schema_csn = standalone.schema.get_schema_csn()

# Get a list of ldap.schema.models.ObjectClass objects for all objectClasses supported by this instance
objectclasses = standalone.schema.get_objectclasses()

# Get a list of ldap.schema.models.AttributeType objects for all attributeTypes supported by this instance
attributetypes = standalone.schema.get_attributetypes()

# Get a list of the server defined matching rules
matchingrules = standalone.schema.get_matchingrules()

# Get a single matching rule instance that matches the mr_name. Returns None if the matching rule doesn't exist
matchingrule = standalone.schema.query_matchingrule(matchingrule_name)

# Get a single ObjectClass instance that matches objectclassname. Returns None if the objectClass doesn't exist
objectclass = standalone.schema.query_objectclass(objectclass_name)
    
# Returns a tuple of the AttributeType, and what objectclasses may or must take this attributeType. Returns None if attributetype doesn't
(attributetype, may, must) = standalone.schema.query_attributetype(attributetype_name)

standalone.ldif2db(bename, suffixes, excludeSuffixes, encrypt, import_file)
standalone.db2ldif(bename, suffixes, excludeSuffixes, encrypt, repl_data, outputfile)
standalone.bak2db(archive_dir,bename=None)
standalone.db2bak(archive_dir)
standalone.db2index(bename=None, suffixes=None, attrs=None, vlvTag=None)
standalone.dbscan(bename=None, index=None, key=None, width=None, isRaw=False)
 
# Generate a simple ldif file using the dbgen.pl script, and set the ownership and permissions to match the user that the server runs as
standalone.buildLDIF(number_of_entries, path_to_ldif, suffix='dc=example,dc=com')