|
| 1 | +from importlib import import_module |
| 2 | + |
| 3 | +from django.db import IntegrityError, models |
| 4 | +from django.db.models.fields.related import lazy_related_operation |
| 5 | + |
| 6 | + |
| 7 | +class EmbeddedModelField(models.Field): |
| 8 | + """Field that stores a model instance.""" |
| 9 | + |
| 10 | + def __init__(self, embedded_model=None, *args, **kwargs): |
| 11 | + """ |
| 12 | + `embedded_model` is the model class of the instance that will be |
| 13 | + stored. Like other relational fields, it may also be passed as a |
| 14 | + string. |
| 15 | + """ |
| 16 | + self.embedded_model = embedded_model |
| 17 | + super().__init__(*args, **kwargs) |
| 18 | + |
| 19 | + def deconstruct(self): |
| 20 | + name, path, args, kwargs = super().deconstruct() |
| 21 | + if path.startswith("django_mongodb_backend.fields.embedded_model"): |
| 22 | + path = path.replace( |
| 23 | + "django_mongodb_backend.fields.embedded_model", "django_mongodb_backend.fields" |
| 24 | + ) |
| 25 | + if self.embedded_model: |
| 26 | + kwargs["embedded_model"] = self.embedded_model |
| 27 | + return name, path, args, kwargs |
| 28 | + |
| 29 | + def get_internal_type(self): |
| 30 | + return "EmbeddedModelField" |
| 31 | + |
| 32 | + def _set_model(self, model): |
| 33 | + """ |
| 34 | + Resolve embedded model class once the field knows the model it belongs |
| 35 | + to. |
| 36 | +
|
| 37 | + If the model argument passed to __init__() was a string, resolve that |
| 38 | + string to the corresponding model class, similar to relation fields. |
| 39 | + However, we need to know our own model to generate a valid key |
| 40 | + for the embedded model class lookup and EmbeddedModelFields are |
| 41 | + not contributed_to_class if used in iterable fields. Thus the |
| 42 | + collection field sets this field's "model" attribute in its |
| 43 | + contribute_to_class(). |
| 44 | + """ |
| 45 | + self._model = model |
| 46 | + if model is not None and isinstance(self.embedded_model, str): |
| 47 | + |
| 48 | + def _resolve_lookup(_, resolved_model): |
| 49 | + self.embedded_model = resolved_model |
| 50 | + |
| 51 | + lazy_related_operation(_resolve_lookup, model, self.embedded_model) |
| 52 | + |
| 53 | + model = property(lambda self: self._model, _set_model) |
| 54 | + |
| 55 | + def stored_model(self, column_values): |
| 56 | + """ |
| 57 | + Return the fixed embedded_model this field was initialized |
| 58 | + with (typed embedding) or tries to determine the model from |
| 59 | + _module / _model keys stored together with column_values |
| 60 | + (untyped embedding). |
| 61 | +
|
| 62 | + Give precedence to the field's definition model, as silently using a |
| 63 | + differing serialized one could hide some data integrity problems. |
| 64 | +
|
| 65 | + Note that a single untyped EmbeddedModelField may process |
| 66 | + instances of different models (especially when used as a type |
| 67 | + of a collection field). |
| 68 | + """ |
| 69 | + module = column_values.pop("_module", None) |
| 70 | + model = column_values.pop("_model", None) |
| 71 | + if self.embedded_model is not None: |
| 72 | + return self.embedded_model |
| 73 | + if module is not None: |
| 74 | + return getattr(import_module(module), model) |
| 75 | + raise IntegrityError( |
| 76 | + "Untyped EmbeddedModelField trying to load data without serialized model class info." |
| 77 | + ) |
| 78 | + |
| 79 | + def from_db_value(self, value, expression, connection): |
| 80 | + return self.to_python(value) |
| 81 | + |
| 82 | + def to_python(self, value): |
| 83 | + """ |
| 84 | + Passes embedded model fields' values through embedded fields |
| 85 | + to_python methods and reinstiatates the embedded instance. |
| 86 | +
|
| 87 | + We expect to receive a field.attname => value dict together |
| 88 | + with a model class from back-end database deconversion (which |
| 89 | + needs to know fields of the model beforehand). |
| 90 | + """ |
| 91 | + # Either the model class has already been determined during |
| 92 | + # deconverting values from the database or we've got a dict |
| 93 | + # from a deserializer that may contain model class info. |
| 94 | + if isinstance(value, tuple): |
| 95 | + embedded_model, attribute_values = value |
| 96 | + elif isinstance(value, dict): |
| 97 | + embedded_model = self.stored_model(value) |
| 98 | + attribute_values = value |
| 99 | + else: |
| 100 | + return value |
| 101 | + # Create the model instance. |
| 102 | + instance = embedded_model( |
| 103 | + **{ |
| 104 | + # Pass values through respective fields' to_python(), leaving |
| 105 | + # fields for which no value is specified uninitialized. |
| 106 | + field.attname: field.to_python(attribute_values[field.attname]) |
| 107 | + for field in embedded_model._meta.fields |
| 108 | + if field.attname in attribute_values |
| 109 | + } |
| 110 | + ) |
| 111 | + instance._state.adding = False |
| 112 | + return instance |
| 113 | + |
| 114 | + def get_db_prep_save(self, embedded_instance, connection): |
| 115 | + """ |
| 116 | + Apply pre_save() and get_db_prep_save() of embedded instance |
| 117 | + fields and passes a field => value mapping down to database |
| 118 | + type conversions. |
| 119 | +
|
| 120 | + The embedded instance will be saved as a column => value dict |
| 121 | + in the end (possibly augmented with info about instance's model |
| 122 | + for untyped embedding), but because we need to apply database |
| 123 | + type conversions on embedded instance fields' values and for |
| 124 | + these we need to know fields those values come from, we need to |
| 125 | + entrust the database layer with creating the dict. |
| 126 | + """ |
| 127 | + if embedded_instance is None: |
| 128 | + return None |
| 129 | + # The field's value should be an instance of the model given in |
| 130 | + # its declaration or at least of some model. |
| 131 | + embedded_model = self.embedded_model or models.Model |
| 132 | + if not isinstance(embedded_instance, embedded_model): |
| 133 | + raise TypeError( |
| 134 | + f"Expected instance of type {embedded_model!r}, not {type(embedded_instance)!r}." |
| 135 | + ) |
| 136 | + # Apply pre_save() and get_db_prep_save() of embedded instance |
| 137 | + # fields, create the field => value mapping to be passed to |
| 138 | + # storage preprocessing. |
| 139 | + field_values = {} |
| 140 | + add = embedded_instance._state.adding |
| 141 | + for field in embedded_instance._meta.fields: |
| 142 | + value = field.get_db_prep_save( |
| 143 | + field.pre_save(embedded_instance, add), connection=connection |
| 144 | + ) |
| 145 | + # Exclude unset primary keys (e.g. {'id': None}). |
| 146 | + if field.primary_key and value is None: |
| 147 | + continue |
| 148 | + field_values[field.attname] = value |
| 149 | + if self.embedded_model is None: |
| 150 | + # Untyped fields must store model info alongside values. |
| 151 | + field_values.update( |
| 152 | + ( |
| 153 | + ("_module", embedded_instance.__class__.__module__), |
| 154 | + ("_model", embedded_instance.__class__.__name__), |
| 155 | + ) |
| 156 | + ) |
| 157 | + # This instance will exist in the database soon. |
| 158 | + # TODO.XXX: Ensure that this doesn't cause race conditions. |
| 159 | + embedded_instance._state.adding = False |
| 160 | + return field_values |
| 161 | + |
| 162 | + def validate(self, value, model_instance): |
| 163 | + super().validate(value, model_instance) |
| 164 | + if self.embedded_model is None: |
| 165 | + return |
| 166 | + for field in self.embedded_model._meta.fields: |
| 167 | + attname = field.attname |
| 168 | + field.validate(getattr(value, attname), model_instance) |
0 commit comments