Purchase form

model/modelstorage.py

@@ -221,6 +221,72 @@ class ModelStorage(Model):
             }
         return json.dumps(values, sort_keys=True, ensure_ascii=False)
 
+    @staticmethod
+    def _iter_log_commands(value):
+        if not isinstance(value, (list, tuple)):
+            return
+        for item in value:
+            if (isinstance(item, (list, tuple))
+                    and item and isinstance(item[0], str)):
+                command = item[0]
+                if len(item) >= 3:
+                    yield command, item[1], item[2]
+                elif len(item) >= 2:
+                    yield command, item[1], None
+        if value and all(isinstance(item, (list, tuple)) for item in value):
+            return
+        index = 0
+        while index < len(value):
+            command = value[index]
+            if not isinstance(command, str):
+                index += 1
+                continue
+            if command == 'write':
+                if index + 2 >= len(value):
+                    break
+                yield command, value[index + 1], value[index + 2]
+                index += 3
+                continue
+            if index + 1 >= len(value):
+                break
+            yield command, value[index + 1], None
+            index += 2
+
+    @classmethod
+    def _nested_log_values(cls, values):
+        nested_old = {}
+        nested_new = {}
+        for field_name, value in values.items():
+            field = cls._fields.get(field_name)
+            if not field or not hasattr(field, 'get_target'):
+                continue
+            commands = list(cls._iter_log_commands(value) or [])
+            write_commands = [
+                (ids, command_values)
+                for command, ids, command_values in commands
+                if command == 'write' and command_values]
+            if not write_commands:
+                continue
+            Target = field.get_target()
+            field_old = {}
+            field_new = {}
+            for ids, command_values in write_commands:
+                target_ids = [int(i) for i in ids]
+                field_names = list(sorted(command_values.keys()))
+                with without_check_access():
+                    rows = Target.read(target_ids, field_names)
+                for row in rows:
+                    record_id = str(row['id'])
+                    field_old.setdefault(record_id, {}).update({
+                            name: row.get(name)
+                            for name in field_names
+                            })
+                    field_new.setdefault(record_id, {}).update(command_values)
+            if field_old or field_new:
+                nested_old[field_name] = field_old
+                nested_new[field_name] = field_new
+        return nested_old, nested_new
+
     @classmethod
     def create(cls, vlist):
         '''
@@ -304,11 +370,16 @@ class ModelStorage(Model):
                             }
                         for row in cls.read(
                             [r.id for r in records], fields_names)}
+                nested_old, nested_new = cls._nested_log_values(values)
                 for record in records:
+                    record_old_values = old_values.get(record.id, {})
+                    record_new_values = values.copy()
+                    record_old_values.update(nested_old)
+                    record_new_values.update(nested_new)
                     cls.log([record], 'write', ','.join(fields_names),
                         old_values=cls._log_value_text(
-                            old_values.get(record.id, {})),
-                        new_values=cls._log_value_text(values))
+                            record_old_values),
+                        new_values=cls._log_value_text(record_new_values))
 
         ModelAccess.check(cls.__name__, 'write')
         ModelFieldAccess.check(cls.__name__, all_fields, 'write')