allow dynamically adding object classes to types

Doing so changes the type of an object and automatically registers new
fields. This requires separately describing the fields in an object
class.

diff --git a/ldapdb/backends/ldap/compiler.py b/ldapdb/backends/ldap/compiler.py
index 972606ff4589147a60ec52aa36b26038e047dbe5..3636ede49732edf247d1580a7e5340cfb807e2d4 100644 (file)
--- a/ldapdb/backends/ldap/compiler.py
+++ b/ldapdb/backends/ldap/compiler.py
@@ -46,7 +46,12 @@ def get_lookup_operator(lookup_type):
         return '='
 
 def query_as_ldap(query):
-    filterstr = ''.join(['(objectClass=%s)' % cls for cls in query.model.object_classes])
+    # TODO: Filtering on objectClass temporarily disabled, since this
+    # breaks Model.save() after an objectclass was added (it queries the
+    # database for the old values to see what changed, but filtering on
+    # the new objectclasses does not return the object).
+    #filterstr = ''.join(['(objectClass=%s)' % cls for cls in query.model.object_classes])
+    filterstr = ''
     sql, params = where_as_ldap(query.where)
     filterstr += sql
     return '(&%s)' % filterstr

diff --git a/ldapdb/models/__init__.py b/ldapdb/models/__init__.py
index 7dc12ed53257062fde9024bd7966218e86f6ac03..ae3a4e498378915894c1ccf37729b3589a57beb8 100644 (file)
--- a/ldapdb/models/__init__.py
+++ b/ldapdb/models/__init__.py
@@ -32,4 +32,4 @@
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 
-from ldapdb.models.base import Model
+from ldapdb.models.base import Model, ObjectClass

diff --git a/ldapdb/models/base.py b/ldapdb/models/base.py
index 8cce0878b0c5e5f71177e837292a4a52b2de01e8..85353460ef1661e64283f54db73f20de27875ca1 100644 (file)
--- a/ldapdb/models/base.py
+++ b/ldapdb/models/base.py
@@ -40,6 +40,10 @@ from django.db import connections, router
 from django.db.models import signals
 
 import ldapdb
+import fields
+
+# Dict containing 
+object_classes = {}
 
 class Model(django.db.models.base.Model):
     """
@@ -114,6 +118,7 @@ class Model(django.db.models.base.Model):
             # update an existing entry
             record_exists = True
             modlist = []
+            modlist.append((ldap.MOD_REPLACE, 'objectClass', [x.encode(connection.charset) for x in self.object_classes]))
             orig = self.__class__.objects.get(pk=self.saved_pk)
             for field in self._meta.fields:
                 if not field.db_column:
@@ -143,6 +148,58 @@ class Model(django.db.models.base.Model):
         self.saved_pk = self.pk
         signals.post_save.send(sender=self.__class__, instance=self, created=(not record_exists))
 
+    def add_object_class(self, oc):
+        """
+        Add an extra object class to this object. The added objectclass
+        must be defined as a subclass of ObjectClass. This changes the
+        type of this object to add the fields of the new
+        objectclass.
+
+        The objectclass passed can be a string naming the objectclass,
+        or an ObjectClass subclass.
+        """
+
+        # The new class is a subclass of Model
+        bases = [Model] + list(Model.__bases__)
+
+        object_classes = self.__class__.object_classes
+        object_classes.append(oc)
+
+        dict_ = {
+            # Copy the module from Model
+            '__module__': Model.__module__,
+            # Generate some documentation
+            '__doc__': 'Automatically generated class for LDAP objects with objectclasses: ' + (', '.join(object_classes)),
+            # Add a class variable containing the object_classes
+            'object_classes': object_classes,
+            # Copy the base_dn from the old class
+            'base_dn': self.__class__.base_dn,
+        }
+
+        # Add all current fields, but leave out fields that Model
+        # already has (these will be added by Django later, since we
+        # make the new class a subclass of Model).
+        dict_.update([(f.name, f) for f in self._meta.fields if not f in Model._meta.fields])
+
+        # If the passed object class is a string, resolve it to an
+        # ObjectClass object.
+        if (isinstance(oc, basestring)):
+            oc = ObjectClass.object_classes[oc]
+
+        # Copy all fields (e.g., subclasses of Field) from the new
+        # ObjectClass
+        for k,v in oc.__dict__.items():
+            if isinstance(v, django.db.models.fields.Field):
+                dict_[k] = v
+
+        # Generate a name for the class (gotta have something...)
+        name = '_'.join(object_classes)
+
+        # And finally, generate the type
+        self.__class__ = type(name, tuple(bases), dict_)
+
+    # TODO: remove_object_class
+
     @classmethod
     def scoped(base_class, base_dn):
         """
@@ -157,3 +214,16 @@ class Model(django.db.models.base.Model):
 
     class Meta:
         abstract = True
+
+class ObjectClass(object):
+    """
+    Superclass for LDAP objectclass descriptors.
+    """
+
+    # Mapping from objectclass name (string) to the ObjectClass subclass
+    # that describes it. Used when loading items from the database or
+    # when adding object classes.
+    #
+    # TODO: Automatically fill this list from a fancy metaclass
+    object_classes = {}
+