From d8c01bc4028d5b030667acf34d003d8145c8c979 Mon Sep 17 00:00:00 2001
From: Matthijs Kooijman <matthijs@stdin.nl>
Date: Sat, 13 Aug 2011 22:07:06 +0200
Subject: [PATCH] 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.
---
 ldapdb/backends/ldap/compiler.py |  7 +++-
 ldapdb/models/__init__.py        |  2 +-
 ldapdb/models/base.py            | 70 ++++++++++++++++++++++++++++++++
 3 files changed, 77 insertions(+), 2 deletions(-)

diff --git a/ldapdb/backends/ldap/compiler.py b/ldapdb/backends/ldap/compiler.py
index 972606f..3636ede 100644
--- 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 7dc12ed..ae3a4e4 100644
--- 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 8cce087..8535346 100644
--- 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 = {}
+
-- 
2.30.2