python-win-ad 0.6.1__tar.gz → 0.6.3__tar.gz

{python-win-ad-0.6.1 → python_win_ad-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-win-ad
-Version: 0.6.1
+Version: 0.6.3
 Summary: An Object-Oriented Active Directory management framework built on ADSI
 Home-page: https://github.com/jcarswell/pyad/
 Author: Zakir Durumeric
@@ -17,14 +17,15 @@ Classifier: Natural Language :: English
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Topic :: System :: Systems Administration :: Authentication/Directory :: LDAP
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Obsoletes: pyad
 Requires-Python: >=3.6
 License-File: LICENSE
+Requires-Dist: setuptools
+Requires-Dist: pywin32
 
 .. image:: https://img.shields.io/badge/code%20style-black-000000.svg
     :align: center

{python-win-ad-0.6.1 → python_win_ad-0.6.3}/pyad/__init__.py

@@ -1,3 +1,7 @@
+# package logger
+import logging
+logging.basicConfig(level=logging.WARNING)
+
 __all__ = [
     "set_defaults",
     "ADQuery",

{python-win-ad-0.6.1 → python_win_ad-0.6.3}/pyad/adbase.py

@@ -1,17 +1,20 @@
+import logging
 import sys
 import win32com.client
 
 from .pyadexceptions import SetupError
 
+logger = logging.getLogger(__name__)
 _adsi_provider = win32com.client.Dispatch("ADsNameSpaces")
 
 try:
     # Discover default domain and forest information
     __default_domain_obj = _adsi_provider.GetObject("", "LDAP://rootDSE")
 except:
-    # If there was an error, this this computer might not be on a domain.
-    print(
-        "WARN: unable to connect to default domain. Computer is likely not attached to an AD domain"
+    # If there was an error, this computer might not be on a domain.
+    logger.info(
+        "Unable to connect to default domain. "
+        "Computer is likely not attached to an AD domain."
     )
     __default_domain_obj = None
     _default_detected_forest = None

python_win_ad-0.6.3/pyad/adcontainer.py

@@ -0,0 +1,238 @@
+import pywintypes
+
+from typing import Any, Dict, List
+from .adobject import ADObject
+from .aduser import ADUser
+from .adcomputer import ADComputer
+from .adgroup import ADGroup
+from . import pyadconstants
+from . import pyadutils
+
+
+class ADContainer(ADObject):
+    def get_children_iter(
+        self, recursive: bool = False, filter: List[ADObject] = None
+    ) -> ADObject:
+        """
+        Iterate over the children objects in the container.
+
+        :param recursive: enumerate all containers with in the object,
+            defaults to False
+        :type recursive: bool, optional
+        :param filter: filter to only specific object classes ie ADUser,
+            defaults to None
+        :type filter: List[ADObject], optional
+        :yield: _description_
+        :rtype: _type_
+        """
+        for com_object in self._ldap_adsi_obj:
+            q = ADObject.from_com_object(com_object)
+            q.adjust_pyad_type()
+            if q.type == "organizationalUnit" and recursive:
+                for c in q.get_children_iter(recursive=recursive):
+                    if not filter or c.__class__ in filter:
+                        yield c
+            if not filter or q.__class__ in filter:
+                yield q
+
+    def get_children(
+        self, recursive: bool = False, filter: List[ADObject] = None
+    ) -> list:
+        """
+        returns a list of child containers with in the current container. Optionally
+        the list can be filtered to specific object classes and search through child
+        containers recursively.
+
+        :param recursive: include children from sub-containers, defaults to False
+        :type recursive: bool, optional
+        :param filter: filter to only specific object classes ie ADUser, defaults to None
+        :type filter: List[ADObject], optional
+        :return: a list of all child objects
+        :rtype: list
+        """
+
+        return list(self.get_children_iter(recursive=recursive, filter=filter))
+
+    def __create_object(self, type_: str, name: str) -> ADObject:
+        prefix = "ou" if type_ == "organizationalUnit" else "cn"
+        prefixed_name = "=".join((prefix, name))
+        return self._ldap_adsi_obj.Create(type_, prefixed_name)
+
+    def create_user(
+        self,
+        name: str,
+        password: str = None,
+        upn_suffix: str = None,
+        enable: bool = True,
+        optional_attributes: dict = {},
+    ) -> ADUser:
+        """
+        Create a new user object in the container.
+
+        :param name: The name of the user
+        :type name: str
+        :param password: The password for the user it is strongly recommended to
+            populate this parameter as the account will be created with password
+            not required which will not get clear within AD leading to a security
+            vulnerability.
+        :type password: str, optional
+        :param upn_suffix: The upn suffix for the user, defaults to default upn
+            suffix for the domain.
+        :type upn_suffix: str, optional
+        :param enable: Whether the user should be enabled or disabled, defaults to True
+        :type enable: bool, optional
+        :param optional_attributes: List of additional attribute to set, defaults to {}
+        :type optional_attributes: dict, optional
+        :return: the created user object
+        :rtype: ADUser
+        """
+
+        pyadobj = None
+
+        try:
+            if not upn_suffix:
+                upn_suffix = self.get_domain().get_default_upn()
+            upn = "@".join((name, upn_suffix))
+            obj = self.__create_object("user", name)
+            obj.Put("sAMAccountName", optional_attributes.get("sAMAccountName", name))
+            obj.Put("userPrincipalName", upn)
+            obj.SetInfo()
+            pyadobj = ADUser.from_com_object(obj)
+
+            if enable:
+                pyadobj.enable()
+
+            if password:
+                pyadobj.set_password(password)
+                pyadobj.set_user_account_control_setting("PASSWD_NOTREQD", False)
+
+            pyadobj.set_user_account_control_setting("NORMAL_ACCOUNT", True)
+            pyadobj.update_attributes(optional_attributes)
+            return pyadobj
+        except pywintypes.com_error as e:
+            if pyadobj:
+                # clean up the object if it was created
+                pyadobj.delete()
+            pyadutils.pass_up_com_exception(e)
+
+    def create_group(
+        self,
+        name: str,
+        security_enabled: bool = True,
+        scope: str = "GLOBAL",
+        optional_attributes: Dict[str, Any] = {},
+    ) -> ADGroup:
+        """
+        Create a new group object in the container
+
+        :param name: The Group Name
+        :type name: str
+        :param security_enabled: If this is a security enabled group or a distribution
+            group, defaults to True
+        :type security_enabled: bool, optional
+        :param scope: The scope of group. Must be one of [GLOBAL, LOCAL, UNIVERSAL].
+            Defaults to "GLOBAL"
+        :type scope: str, optional
+        :param optional_attributes: Additional attributes to set when creating the
+            object, defaults to {}
+        :type optional_attributes: Dict[str,Any], optional
+        :return: The created group object
+        :rtype: ADGroup
+        """
+
+        obj = None
+
+        try:
+            obj = self.__create_object("group", name)
+            obj.Put("sAMAccountName", name)
+            val = pyadconstants.ADS_GROUP_TYPE[scope]
+            if security_enabled:
+                val = val | pyadconstants.ADS_GROUP_TYPE["SECURITY_ENABLED"]
+            obj.Put("groupType", val)
+            obj.SetInfo()
+            pyadobj = ADGroup.from_com_object(obj)
+            pyadobj.update_attributes(optional_attributes)
+            return pyadobj
+        except pywintypes.com_error as e:
+            if obj:
+                obj.delete()
+            pyadutils.pass_up_com_exception(e)
+        except KeyError:
+            if obj:
+                obj.delete()
+            raise ValueError(f"Invalid scope: {scope}")
+
+    def create_container(
+        self, name: str, optional_attributes: Dict[str, Any] = {}
+    ) -> "ADContainer":
+        """
+        Create a new organizational unit in the container
+
+        :param name: The name of the container
+        :type name: str
+        :param optional_attributes: Additional attributes to set when creating the
+            object, defaults to {}
+        :type optional_attributes: Dict[str,Any], optional
+        :return: the created container object
+        :rtype: ADContainer
+        """
+
+        obj = None
+
+        try:
+            obj = self.__create_object("organizationalUnit", name)
+            obj.SetInfo()
+            pyadobj = ADContainer.from_com_object(obj)
+            pyadobj.update_attributes(optional_attributes)
+            return pyadobj
+        except pywintypes.com_error as e:
+            if obj:
+                obj.delete()
+            pyadutils.pass_up_com_exception(e)
+
+    def create_computer(
+        self, name: str, enable: bool = True, optional_attributes: Dict[str, Any] = {}
+    ) -> ADComputer:
+        """
+        Create a new computer object in the container
+
+        :param name: The computer name
+        :type name: str
+        :param enable: Whether the computer should be enabled or disabled,
+            defaults to True
+        :type enable: bool, optional
+        :param optional_attributes: Additional attributes to set when creating the
+            object, defaults to {}
+        :type optional_attributes: Dict[str,Any], optional
+        :return: the created computer object
+        :rtype: ADComputer
+        """
+
+        obj = None
+
+        try:
+            obj = self.__create_object("computer", name)
+            obj.Put("sAMAccountName", name + "$")
+            if enable:
+                obj.Put("userAccountControl", 4128)
+            else:
+                obj.Put("userAccountControl", 4130)
+            obj.SetInfo()
+            pyadobj = ADComputer.from_com_object(obj)
+            if enable:
+                pyadobj.enable()
+            pyadobj.update_attributes(optional_attributes)
+            return pyadobj
+        except pywintypes.com_error as e:
+            if obj:
+                obj.delete()
+            pyadutils.pass_up_com_exception(e)
+
+    def remove_child(self, child: ADObject) -> None:
+        """Removes the child object from the domain"""
+
+        self._ldap_adsi_obj.Delete(child.type, child.prefixed_cn)
+
+
+ADObject._py_ad_object_mappings["organizationalUnit"] = ADContainer
+ADObject._py_ad_object_mappings["container"] = ADContainer

{python-win-ad-0.6.1 → python_win_ad-0.6.3}/pyad/adobject.py

@@ -1,3 +1,4 @@
+import logging
 import win32com
 import pywintypes
 import time
@@ -16,6 +17,7 @@ from .pyadconstants import (
     ADS_USER_FLAG,
 )
 
+logger = logging.getLogger(__name__)
 
 @total_ordering
 class ADObject(ADBase):
@@ -231,6 +233,37 @@ class ADObject(ADBase):
         else:
             raise AttributeError(attribute)
 
+    def __getitem__(self, key: str):
+        """
+        Get an attribute from the ADObject attributes.
+
+        :param key: The attribute name to retrieve
+        :type key: str
+        :raises AttributeError: if the key does not exist
+        :return: The value of the attribute
+        """
+
+        if hasattr(self._ldap_adsi_obj, key):
+            return self.get_attribute(key, False)
+        else:
+            raise AttributeError(key)
+
+    def __setitem__(self, key: str, value):
+        """
+        Set an attribute on the ADObject.
+
+        :param key: The attribute name to set
+        :type key: str
+        :param value: The value to set the attribute to
+        :type value: Any
+        :raises AttributeError: if the key does not exist
+        """
+
+        if hasattr(self._ldap_adsi_obj, key):
+            self.update_attribute(key, value)
+        else:
+            raise AttributeError(key)
+
     def _flush(self):
         """Commits any changes to the AD object."""
         self._ldap_adsi_obj.SetInfo()
@@ -633,7 +666,7 @@ class ADObject(ADBase):
                             )
                         node.appendChild(text)
                     except:
-                        print("attribute: %s not xml-able" % attribute)
+                        logger.error("attribute: %s not xml-able" % attribute)
                 else:
                     node.setAttribute("type", "multiValued")
                     ok_elem = False
@@ -653,7 +686,7 @@ class ADObject(ADBase):
                                 node.appendChild(valnode)
                                 ok_elem = True
                     except:
-                        print("attribute: %s not xml-able" % attribute)
+                        logger.error("attribute: %s not xml-able" % attribute)
                 if ok_elem:
                     adobj_xml_doc.appendChild(node)
         return doc.toxml(encoding="UTF-8")

{python-win-ad-0.6.1 → python_win_ad-0.6.3}/pyad/pyadexceptions.py

@@ -46,14 +46,18 @@ class InvalidObjectException(noObjectFoundException, win32Exception):
 class InvalidAttribute(BaseException, AttributeError):
     def __str__(self):
         return (
-            'The attribute "%s" is not permitted by the schema definition of the object "%s" (the requested attribute does not exist).'
+            'The attribute "%s" is not permitted by the schema definition of the '
+            'object "%s" (the requested attribute does not exist).'
             % (self.attribute, self.obj)
         )
 
 
 class noExecutedQuery(BaseException):
     def __str__(self):
-        return "No query has been executed. Therefore there are no results to return. Execute a query before requesting results."
+        return (
+            "No query has been executed. Therefore there are no results to return. "
+            "Execute a query before requesting results."
+        )
 
 
 class invalidResults(BaseException):
@@ -62,8 +66,8 @@ class invalidResults(BaseException):
 
     def __str__(self):
         return (
-            "The specified query returned %i results. getSingleResults only functions with a single result."
-            % self.number_results
+            "The specified query returned %i results. getSingleResults only functions "
+            "with a single result." % self.number_results
         )
 
 

{python-win-ad-0.6.1 → python_win_ad-0.6.3}/pyad/pyadutils.py

@@ -41,17 +41,34 @@ def validate_credentials(
         return None
 
 
-def convert_error_code(error_code):
+def convert_error_code(error_code: int) -> int:
     """
     Convert error code from the format returned by pywin32 to the format that Microsoft
     documents everything in.
+
+    :param error_code: error code
+    :type error_code: int
+    :return: The error code in the format Microsoft documents it
+    :rtype: int
     """
 
     return error_code % 2**32
 
 
-# expects the actually pywintypes.com_error exception that's thrown...
-def interpret_com_exception(excp, additional_info={}):
+def interpret_com_exception(
+    excp: "pywintype.com_error", additional_info: dict = {}
+) -> dict:
+    """
+    Convert a pywin32 com_error exception into a dictionary of error information.
+
+    :param excp: pywin32 com_error exception
+    :type excp: pywintype.com_error
+    :param additional_info: any additional information with the error, defaults to {}
+    :type additional_info: dict, optional
+    :return: a dictionary of error information
+    :rtype: dict
+    """
+
     d = {}
     d["error_num"] = convert_error_code(excp.args[2][5])
     # for some reason hex() includes the L for long in the hex...
@@ -87,7 +104,18 @@ def interpret_com_exception(excp, additional_info={}):
     return d
 
 
-def pass_up_com_exception(excp, additional_info={}):
+def pass_up_com_exception(excp: "pywintype.com_error", additional_info: dict = {}):
+    """
+    reparse the com_error into a sane exception and raise it.
+
+    :param excp: the com_error exception
+    :type excp: pywintype.com_error
+    :param additional_info: Additional exception details, defaults to {}
+    :type additional_info: dict, optional
+    :raises excp: if we don't know how to handle the exception raise the original
+        exception
+    """
+
     if excp.__class__ in (genericADSIException, comException, win32Exception):
         raise excp
     else:
@@ -110,9 +138,14 @@ def pass_up_com_exception(excp, additional_info={}):
 
 
 def convert_datetime(adsi_time_com_obj):
-    """Converts 64-bit integer COM object representing time into a python datetime object."""
-    # credit goes to John Nielsen who documented this at
-    # http://docs.activestate.com/activepython/2.6/pywin32/html/com/help/active_directory.html.
+    """
+    Converts 64-bit integer COM object representing time into
+    a python datetime object.
+
+    Credit goes to John Nielsen who documented this at
+    `<http://docs.activestate.com/activepython/2.6/pywin32/html/com/help/active_directory.html>`_.
+    """
+
     if not hasattr(adsi_time_com_obj, "highpart") or not hasattr(
         adsi_time_com_obj, "lowpart"
     ):
@@ -133,19 +166,38 @@ def convert_datetime(adsi_time_com_obj):
     return datetime.datetime.fromtimestamp(date_value)
 
 
-def convert_bigint(obj):
-    # based on http://www.selfadsi.org/ads-attributes/user-usnChanged.htm
+def convert_bigint(obj) -> int:
+    """
+    Converts a ADSI time object to an integer.
+
+    based on http://www.selfadsi.org/ads-attributes/user-usnChanged.htm
+
+    :param obj: the AD bigint object
+    :raises AttributeError: invalid object type
+    :return: the decimal value of the object
+    :rtype: int
+    """
+
     if hasattr(obj, "HighPart") and hasattr(obj, "LowPart"):
         h, l = obj.HighPart, obj.LowPart
         if l < 0:
             h += 1
         return (h << 32) + l
     else:
-        raise ValueError(f"Expected adsi time object got '{obj.__class__.__name__}'")
+        raise AttributeError(
+            f"Expected adsi time object got '{obj.__class__.__name__}'"
+        )
+
 
+def convert_timespan(obj) -> datetime.timedelta:
+    """
+    Converts COM object representing time span to a python time span object.
+
+    :param obj: ADSI time span object
+    :return: the python timedelta object
+    :rtype: datetime.timedelta
+    """
 
-def convert_timespan(obj):
-    """Converts COM object representing time span to a python time span object."""
     as_seconds = (
         abs(convert_bigint(obj)) / 10000000
     )  # number of 100 nanoseconds in a second
@@ -160,7 +212,17 @@ def convert_sid(sid_object):
     return pywintypes.SID(bytes(sid_object))
 
 
-def generate_list(input):
+def generate_list(input) -> list:
+    """
+    converts a set or tuple to a list or returns the input in a list if it is not
+    a list.
+
+    :param input: a list like object or any
+    :type input: list, set, tuple, Any
+    :return: a list
+    :rtype: list
+    """
+
     if type(input) is list:
         return input
     elif type(input) in (set, tuple):
@@ -171,7 +233,16 @@ def generate_list(input):
         ]
 
 
-def escape_path(path):
+def escape_path(path: str) -> str:
+    """
+    escapes a path for use in ADSI.
+
+    :param path: the raw path to escape
+    :type path: str
+    :return: the escaped path
+    :rtype: str
+    """
+
     escapes = (
         ("\+", "+"),
         ("\*", "*"),

{python-win-ad-0.6.1 → python_win_ad-0.6.3}/python_win_ad.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-win-ad
-Version: 0.6.1
+Version: 0.6.3
 Summary: An Object-Oriented Active Directory management framework built on ADSI
 Home-page: https://github.com/jcarswell/pyad/
 Author: Zakir Durumeric
@@ -17,14 +17,15 @@ Classifier: Natural Language :: English
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Topic :: System :: Systems Administration :: Authentication/Directory :: LDAP
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Obsoletes: pyad
 Requires-Python: >=3.6
 License-File: LICENSE
+Requires-Dist: setuptools
+Requires-Dist: pywin32
 
 .. image:: https://img.shields.io/badge/code%20style-black-000000.svg
     :align: center

{python-win-ad-0.6.1 → python_win_ad-0.6.3}/python_win_ad.egg-info/SOURCES.txt

@@ -19,4 +19,6 @@ python_win_ad.egg-info/PKG-INFO
 python_win_ad.egg-info/SOURCES.txt
 python_win_ad.egg-info/dependency_links.txt
 python_win_ad.egg-info/requires.txt
-python_win_ad.egg-info/top_level.txt
+python_win_ad.egg-info/top_level.txt
+tests/tests_adbase.py
+tests/tests_adquery.py

{python-win-ad-0.6.1 → python_win_ad-0.6.3}/setup.py

@@ -12,7 +12,7 @@ def read(fname):
 
 setup(
     name="python-win-ad",
-    version="0.6.1",
+    version="0.6.3",
     author="Zakir Durumeric",
     author_email="zakird@gmail.com",
     maintainer="Josh Carswell",
@@ -38,11 +38,10 @@ setup(
         "Operating System :: Microsoft :: Windows",
         "Topic :: System :: Systems Administration :: Authentication/Directory :: LDAP",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
     ],
     install_requires=["setuptools", "pywin32"],
 )

python_win_ad-0.6.3/tests/tests_adbase.py

@@ -0,0 +1,22 @@
+from .pyadunittest import ADTestCase
+from pyad.adbase import ADBase
+import pyad
+
+class TestADBase(ADTestCase):
+    def setUp(self):
+        # set all defaults back to their default
+        ADBase.default_ldap_server = None
+        ADBase.default_gc_server = None
+        ADBase.default_ldap_port = None
+        ADBase.default_gc_port = None
+    
+    def test_detected_forest(self):
+        self.assertEqual(ADBase.default_domain, self.SANDBOX_DOMAIN)
+    
+    def test_detected_domain(self):
+        self.assertEqual(ADBase.default_forest, self.SANDBOX_FOREST)
+    
+    def test_set_defaults(self):
+        pyad.set_defaults(ldap_server = self.TEST_DC, ldap_port = 389)
+        self.assertEqual(ADBase.default_ldap_server, self.TEST_DC)
+        self.assertEqual(ADBase.default_ldap_port, 389)

python_win_ad-0.6.3/tests/tests_adquery.py

@@ -0,0 +1,53 @@
+from .pyadunittest import ADTestCase
+import pyad
+
+class TestADQuery(ADTestCase):
+    def setUp(self):
+        self.ad_query = pyad.ADQuery()
+    
+    def test_dne_rowcount(self):
+        query = "cn = '%s'" % self.KNOWN_DNE_OBJECT
+        self.ad_query.execute_query(where_clause = query)
+        self.assertEqual(self.ad_query.row_count, 0)
+
+    def test_dne_single_result(self):
+        query = "cn = '%s'" % self.KNOWN_DNE_OBJECT
+        self.ad_query.execute_query(where_clause = query)
+        self.assertEquals(self.ad_query.get_single_result,{})
+
+    def test_dne_all_results(self):
+        query = "cn = '%s'" % self.KNOWN_DNE_OBJECT
+        self.ad_query.execute_query(where_clause = query)
+        self.assertEqual(self.ad_query.get_all_results(), [])
+
+    def test_single_rowcount(self):
+        query = "cn = '%s'" % self.KNOWN_EXISTS_USER
+        self.ad_query.execute_query(where_clause = query)
+        self.assertEqual(self.ad_query.get_row_count(), 1)
+
+    def test_single_single_result(self):
+        query = "cn = '%s'" % self.KNOWN_EXISTS_USER
+        self.ad_query.execute_query(attributes=("cn","distinguishedname"),where_clause = query)
+        self.assertEqual(self.ad_query.get_single_result()['cn'],self.KNOWN_EXISTS_USER)
+
+    def test_single_all_results(self):
+        query = "cn = '%s'" % self.KNOWN_EXISTS_USER
+        self.ad_query.execute_query(attributes=("cn","distinguishedname"),where_clause = query)
+        self.assertEqual(self.ad_query.get_all_results()[0]['cn'],self.KNOWN_EXISTS_USER)
+
+    def test_multiple_rowcount(self):
+        query = "cn = '%s' or cn = '%s'" % (self.KNOWN_EXISTS_USER, self.KNOWN_EXISTS_COMPUTER)
+        self.ad_query.execute_query(where_clause = query)
+        self.assertEqual(self.ad_query.row_count, 2)
+
+    def test_multiple_single_result(self):
+        query = "cn = '%s' or cn = '%s'" % (self.KNOWN_EXISTS_USER, self.KNOWN_EXISTS_COMPUTER)
+        self.ad_query.execute_query(where_clause = query)
+        self.assertIsInstance(self.ad_query.get_single_result,dict)
+
+    def test_multiple_all_results(self):
+        query = "cn = '%s' or cn = '%s'" % (self.KNOWN_EXISTS_USER, self.KNOWN_EXISTS_COMPUTER)
+        self.ad_query.execute_query(attributes=("cn","distinguishedname"),where_clause = query)
+        r = map(lambda x: x['cn'], self.ad_query.get_all_results())
+        k = [self.KNOWN_EXISTS_USER, self.KNOWN_EXISTS_COMPUTER]
+        self.assertEqual(r.sort(),k.sort())

python-win-ad-0.6.1/pyad/adcontainer.py

@@ -1,123 +0,0 @@
-import pywintypes
-
-from .adobject import ADObject
-from .aduser import ADUser
-from .adcomputer import ADComputer
-from .adgroup import ADGroup
-from . import pyadconstants
-from . import pyadutils
-
-
-class ADContainer(ADObject):
-    def get_children_iter(self, recursive=False, filter=None):
-        for com_object in self._ldap_adsi_obj:
-            q = ADObject.from_com_object(com_object)
-            q.adjust_pyad_type()
-            if q.type == "organizationalUnit" and recursive:
-                for c in q.get_children_iter(recursive=recursive):
-                    if not filter or c.__class__ in filter:
-                        yield c
-            if not filter or q.__class__ in filter:
-                yield q
-
-    def get_children(self, recursive=False, filter=None) -> list:
-        """
-        Iterate over the children objects in the container.
-
-        :param recursive: include children from sub-containers, defaults to False
-        :type recursive: bool, optional
-        :param filter: filter to only specific object classes ie ADUser, defaults to None
-        :type filter: object, optional
-        :return: a list of all child objects
-        :rtype: list
-        """
-        return list(self.get_children_iter(recursive=recursive, filter=filter))
-
-    def __create_object(self, type_, name):
-        prefix = "ou" if type_ == "organizationalUnit" else "cn"
-        prefixed_name = "=".join((prefix, name))
-        return self._ldap_adsi_obj.Create(type_, prefixed_name)
-
-    def create_user(
-        self, name, password=None, upn_suffix=None, enable=True, optional_attributes={}
-    ):
-        """Create a new user object in the container"""
-
-        try:
-            if not upn_suffix:
-                upn_suffix = self.get_domain().get_default_upn()
-            upn = "@".join((name, upn_suffix))
-            obj = self.__create_object("user", name)
-            obj.Put("sAMAccountName", optional_attributes.get("sAMAccountName", name))
-            obj.Put("userPrincipalName", upn)
-            obj.SetInfo()
-            pyadobj = ADUser.from_com_object(obj)
-            if enable:
-                pyadobj.enable()
-            if password:
-                pyadobj.set_password(password)
-            pyadobj.set_user_account_control_setting("NORMAL_ACCOUNT", True)
-            pyadobj.set_user_account_control_setting("PASSWD_NOTREQD", False)
-            pyadobj.update_attributes(optional_attributes)
-            return pyadobj
-        except pywintypes.com_error as e:
-            pyadutils.pass_up_com_exception(e)
-
-    def create_group(
-        self, name, security_enabled=True, scope="GLOBAL", optional_attributes={}
-    ):
-        """Create a new group object in the container"""
-
-        try:
-            obj = self.__create_object("group", name)
-            obj.Put("sAMAccountName", name)
-            val = pyadconstants.ADS_GROUP_TYPE[scope]
-            if security_enabled:
-                val = val | pyadconstants.ADS_GROUP_TYPE["SECURITY_ENABLED"]
-            obj.Put("groupType", val)
-            obj.SetInfo()
-            pyadobj = ADGroup.from_com_object(obj)
-            pyadobj.update_attributes(optional_attributes)
-            return pyadobj
-        except pywintypes.com_error as e:
-            pyadutils.pass_up_com_exception(e)
-
-    def create_container(self, name, optional_attributes={}):
-        """Create a new organizational unit in the container"""
-
-        try:
-            obj = self.__create_object("organizationalUnit", name)
-            obj.SetInfo()
-            pyadobj = ADContainer.from_com_object(obj)
-            pyadobj.update_attributes(optional_attributes)
-            return pyadobj
-        except pywintypes.com_error as e:
-            pyadutils.pass_up_com_exception(e)
-
-    def create_computer(self, name, enable=True, optional_attributes={}):
-        """Create a new computer object in the container"""
-
-        try:
-            obj = self.__create_object("computer", name)
-            obj.Put("sAMAccountName", name + "$")
-            if enable:
-                obj.Put("userAccountControl", 4128)
-            else:
-                obj.Put("userAccountControl", 4130)
-            obj.SetInfo()
-            pyadobj = ADComputer.from_com_object(obj)
-            if enable:
-                pyadobj.enable()
-            pyadobj.update_attributes(optional_attributes)
-            return pyadobj
-        except pywintypes.com_error as e:
-            pyadutils.pass_up_com_exception(e)
-
-    def remove_child(self, child) -> None:
-        """Removes the child object from the domain"""
-
-        self._ldap_adsi_obj.Delete(child.type, child.prefixed_cn)
-
-
-ADObject._py_ad_object_mappings["organizationalUnit"] = ADContainer
-ADObject._py_ad_object_mappings["container"] = ADContainer