From 30b1403cdc76a1286ceccc06107e4409276730ef Mon Sep 17 00:00:00 2001 From: Albert Cervera i Areny Date: Sun, 6 Jan 2013 22:18:13 +0100 Subject: [PATCH] Use a list of dictionaries in create(). issue2358 review266002 --- CHANGELOG | 1 + doc/ref/models/fields.rst | 4 +- doc/ref/models/models.rst | 8 +- trytond/convert.py | 48 +- trytond/ir/action.py | 204 +++---- trytond/ir/attachment.py | 8 +- trytond/ir/cron.py | 8 +- trytond/ir/lang.py | 4 +- trytond/ir/model.py | 16 +- trytond/ir/module/module.py | 13 +- trytond/ir/property.py | 2 +- trytond/ir/rule.py | 8 +- trytond/ir/sequence.py | 15 +- trytond/ir/translation.py | 146 ++--- trytond/ir/trigger.py | 15 +- trytond/ir/ui/menu.py | 21 +- trytond/ir/ui/view.py | 39 +- trytond/model/fields/many2many.py | 25 +- trytond/model/fields/one2many.py | 12 +- trytond/model/fields/one2one.py | 5 +- trytond/model/modelsingleton.py | 14 +- trytond/model/modelsql.py | 322 ++++++----- trytond/model/modelstorage.py | 54 +- trytond/res/group.py | 4 +- trytond/res/ir.py | 27 +- trytond/res/request.py | 5 +- trytond/res/user.py | 12 +- trytond/security.py | 2 +- trytond/tests/test_access.py | 214 +++---- trytond/tests/test_exportdata.py | 188 +++---- trytond/tests/test_fields.py | 801 +++++++++++++-------------- trytond/tests/test_model_inherits.py | 40 +- trytond/tests/test_modelsingleton.py | 6 +- trytond/tests/test_modelsql.py | 2 +- trytond/tests/test_mptt.py | 11 +- trytond/tests/test_sequence.py | 56 +- trytond/tests/test_trigger.py | 160 +++--- trytond/tests/test_wizard.py | 14 +- trytond/tests/test_workflow.py | 2 +- trytond/webdav/webdav.py | 27 +- trytond/wizard/wizard.py | 2 +- 41 files changed, 1332 insertions(+), 1233 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index b3d8cd5ed9..f7f8d3d225 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,3 +1,4 @@ +* Use lists of values in create * (Field, Operator, Operand) are replaced by Domain on Rule * Add global search * Replace view shortcut by menu favorite diff --git a/doc/ref/models/fields.rst b/doc/ref/models/fields.rst index 9294444435..42c5e6cc2e 100644 --- a/doc/ref/models/fields.rst +++ b/doc/ref/models/fields.rst @@ -433,8 +433,8 @@ model. This field accepts as written value a list of tuples like this: - - ``('create', {: value, ...})``: it will create a new target - record and link it to this one. + - ``('create', [{: value, ...}, ...])``: it will create new + target records and link them to this one. - ``('write'[, ids, ...], {: value, ...})``: it will write values to target ids. diff --git a/doc/ref/models/models.rst b/doc/ref/models/models.rst index fe75c43bf4..34cb6bbac2 100644 --- a/doc/ref/models/models.rst +++ b/doc/ref/models/models.rst @@ -231,12 +231,12 @@ Static methods: CLass methods: -.. classmethod:: ModelStorage.create(values) +.. classmethod:: ModelStorage.create(vlist) - Create a record. ``values`` is a dictionary with fields names as key and - created values as value and return the new instance. + Create records. ``vlist`` is list of dictionaries with fields names as key + and created values as value and return the list of new instances. -.. classmethod:: ModelStorage.trigger_create(record) +.. classmethod:: ModelStorage.trigger_create(records) Trigger create actions. It will call actions defined in ``ir.trigger`` if ``on_create`` is set and ``condition`` is true. diff --git a/trytond/convert.py b/trytond/convert.py index 23fe53cd52..1984bd6e5e 100644 --- a/trytond/convert.py +++ b/trytond/convert.py @@ -583,7 +583,7 @@ class TrytondXmlHandler(sax.handler.ContentHandler): if not record: with Transaction().set_context( module=module, language='en_US'): - record = Model.create(values) + record, = Model.create([values]) # reset_browsercord self.fs2db.reset_browsercord( @@ -607,13 +607,13 @@ class TrytondXmlHandler(sax.handler.ContentHandler): 'inherit': True, }) else: - data = self.ModelData.create({ - 'fs_id': fs_id, - 'module': module, - 'model': table, - 'db_id': inherit_db_ids[table], - 'inherit': True, - }) + data, = self.ModelData.create([{ + 'fs_id': fs_id, + 'module': module, + 'model': table, + 'db_id': inherit_db_ids[table], + 'inherit': True, + }]) inherit_mdata_ids.append((table, data.id)) data = self.ModelData.search([ @@ -739,7 +739,7 @@ class TrytondXmlHandler(sax.handler.ContentHandler): else: # this record is new, create it in the db: with Transaction().set_context(module=module, language='en_US'): - record = Model.create(values) + record, = Model.create([values]) inherit_db_ids = {} for table, field_name, field in ( @@ -752,25 +752,25 @@ class TrytondXmlHandler(sax.handler.ContentHandler): for key in values: values[key] = self._clean_value(key, record) - for table in inherit_db_ids.keys(): - self.ModelData.create({ + to_create = [{ 'fs_id': fs_id, - 'model': table, + 'model': model, 'module': module, - 'db_id': inherit_db_ids[table], + 'db_id': record.id, 'values': str(values), - 'inherit': True, 'noupdate': self.noupdate, - }) - - mdata = self.ModelData.create({ - 'fs_id': fs_id, - 'model': model, - 'module': module, - 'db_id': record.id, - 'values': str(values), - 'noupdate': self.noupdate, - }) + }] + for table in inherit_db_ids.keys(): + to_create.append({ + 'fs_id': fs_id, + 'model': table, + 'module': module, + 'db_id': inherit_db_ids[table], + 'values': str(values), + 'inherit': True, + 'noupdate': self.noupdate, + }) + mdata = self.ModelData.create(to_create)[0] # update fs2db: self.fs2db.set(module, fs_id, { diff --git a/trytond/ir/action.py b/trytond/ir/action.py index 4e9689eb0d..a2d9968843 100644 --- a/trytond/ir/action.py +++ b/trytond/ir/action.py @@ -175,12 +175,14 @@ class ActionKeyword(ModelSQL, ModelView): super(ActionKeyword, cls).delete(keywords) @classmethod - def create(cls, vals): + def create(cls, vlist): ModelView._fields_view_get_cache.clear() ModelView._view_toolbar_get_cache.clear() cls._get_keyword_cache.clear() - vals = cls._convert_vals(vals) - return super(ActionKeyword, cls).create(vals) + new_vlist = [] + for vals in vlist: + new_vlist.append(cls._convert_vals(vals)) + return super(ActionKeyword, cls).create(new_vlist) @classmethod def write(cls, keywords, vals): @@ -509,28 +511,31 @@ class ActionReport(ModelSQL, ModelView): return new_reports @classmethod - def create(cls, vals): - later = {} - vals = vals.copy() - for field in vals: - if (field in cls._fields - and hasattr(cls._fields[field], 'set')): - later[field] = vals[field] - for field in later: - del vals[field] - cursor = Transaction().cursor - if cursor.nextid(cls._table): - cursor.setnextid(cls._table, cursor.currid('ir_action')) - report = super(ActionReport, cls).create(vals) - cursor.execute('SELECT action FROM "' + cls._table + '" ' - 'WHERE id = %s', (report.id,)) - new_id, = cursor.fetchone() - cursor.execute('UPDATE "' + cls._table + '" SET id = %s ' - 'WHERE id = %s', (new_id, report.id)) - cursor.update_auto_increment(cls._table, new_id) - report = cls(new_id) - cls.write([report], later) - return report + def create(cls, vlist): + new_vlist = [] + for vals in vlist: + later = {} + vals = vals.copy() + for field in vals: + if (field in cls._fields + and hasattr(cls._fields[field], 'set')): + later[field] = vals[field] + for field in later: + del vals[field] + cursor = Transaction().cursor + if cursor.nextid(cls._table): + cursor.setnextid(cls._table, cursor.currid('ir_action')) + report, = super(ActionReport, cls).create([vals]) + cursor.execute('SELECT action FROM "' + cls._table + '" ' + 'WHERE id = %s', (report.id,)) + new_id, = cursor.fetchone() + cursor.execute('UPDATE "' + cls._table + '" SET id = %s ' + 'WHERE id = %s', (new_id, report.id)) + cursor.update_auto_increment(cls._table, new_id) + report = cls(new_id) + new_vlist.append(report) + cls.write([report], later) + return new_vlist @classmethod def write(cls, reports, vals): @@ -723,28 +728,31 @@ class ActionActWindow(ModelSQL, ModelView): return pysons @classmethod - def create(cls, vals): - later = {} - vals = vals.copy() - for field in vals: - if (field in cls._fields - and hasattr(cls._fields[field], 'set')): - later[field] = vals[field] - for field in later: - del vals[field] - cursor = Transaction().cursor - if cursor.nextid(cls._table): - cursor.setnextid(cls._table, cursor.currid('ir_action')) - act_window = super(ActionActWindow, cls).create(vals) - cursor.execute('SELECT action FROM "' + cls._table + '" ' - 'WHERE id = %s', (act_window.id,)) - new_id, = cursor.fetchone() - cursor.execute('UPDATE "' + cls._table + '" SET id = %s ' - 'WHERE id = %s', (new_id, act_window.id)) - cursor.update_auto_increment(cls._table, new_id) - act_window = cls(new_id) - cls.write([act_window], later) - return act_window + def create(cls, vlist): + new_vlist = [] + for vals in vlist: + later = {} + vals = vals.copy() + for field in vals: + if (field in cls._fields + and hasattr(cls._fields[field], 'set')): + later[field] = vals[field] + for field in later: + del vals[field] + cursor = Transaction().cursor + if cursor.nextid(cls._table): + cursor.setnextid(cls._table, cursor.currid('ir_action')) + act_window, = super(ActionActWindow, cls).create([vals]) + cursor.execute('SELECT action FROM "' + cls._table + '" ' + 'WHERE id = %s', (act_window.id,)) + new_id, = cursor.fetchone() + cursor.execute('UPDATE "' + cls._table + '" SET id = %s ' + 'WHERE id = %s', (new_id, act_window.id)) + cursor.update_auto_increment(cls._table, new_id) + act_window = cls(new_id) + new_vlist.append(act_window) + cls.write([act_window], later) + return new_vlist @classmethod def write(cls, act_windows, values): @@ -810,11 +818,11 @@ class ActionActWindowView(ModelSQL, ModelView): table.drop_column('multi') @classmethod - def create(cls, values): + def create(cls, vlist): pool = Pool() - window = super(ActionActWindowView, cls).create(values) + windows = super(ActionActWindowView, cls).create(vlist) pool.get('ir.action.keyword')._get_keyword_cache.clear() - return window + return windows @classmethod def write(cls, windows, values): @@ -865,28 +873,31 @@ class ActionWizard(ModelSQL, ModelView): return 'ir.action.wizard' @classmethod - def create(cls, vals): - later = {} - vals = vals.copy() - for field in vals: - if (field in cls._fields - and hasattr(cls._fields[field], 'set')): - later[field] = vals[field] - for field in later: - del vals[field] - cursor = Transaction().cursor - if cursor.nextid(cls._table): - cursor.setnextid(cls._table, cursor.currid('ir_action')) - wizard = super(ActionWizard, cls).create(vals) - cursor.execute('SELECT action FROM "' + cls._table + '" ' - 'WHERE id = %s', (wizard.id,)) - new_id, = cursor.fetchone() - cursor.execute('UPDATE "' + cls._table + '" SET id = %s ' - 'WHERE id = %s', (new_id, wizard.id)) - cursor.update_auto_increment(cls._table, new_id) - wizard = cls(new_id) - cls.write([wizard], later) - return wizard + def create(cls, vlist): + new_vlist = [] + for vals in vlist: + later = {} + vals = vals.copy() + for field in vals: + if (field in cls._fields + and hasattr(cls._fields[field], 'set')): + later[field] = vals[field] + for field in later: + del vals[field] + cursor = Transaction().cursor + if cursor.nextid(cls._table): + cursor.setnextid(cls._table, cursor.currid('ir_action')) + wizard, = super(ActionWizard, cls).create([vals]) + cursor.execute('SELECT action FROM "' + cls._table + '" ' + 'WHERE id = %s', (wizard.id,)) + new_id, = cursor.fetchone() + cursor.execute('UPDATE "' + cls._table + '" SET id = %s ' + 'WHERE id = %s', (new_id, wizard.id)) + cursor.update_auto_increment(cls._table, new_id) + wizard = cls(new_id) + new_vlist.append(wizard) + cls.write([wizard], later) + return new_vlist @classmethod def write(cls, wizards, values): @@ -936,29 +947,32 @@ class ActionURL(ModelSQL, ModelView): return 'new' @classmethod - def create(cls, vals): - later = {} - vals = vals.copy() - for field in vals: - if (field in cls._fields - and hasattr(cls._fields[field], 'set')): - later[field] = vals[field] - for field in later: - del vals[field] - cursor = Transaction().cursor - if cursor.nextid(cls._table): - cursor.setnextid(cls._table, cursor.currid('ir_action')) - url = super(ActionURL, cls).create(vals) - cursor.execute('SELECT action FROM "' + cls._table + '" ' - 'WHERE id = %s', (url.id,)) - new_id, = cursor.fetchone() - cls.write([url], {}) # simulate write to clear the cache - cursor.execute('UPDATE "' + cls._table + '" SET id = %s ' - 'WHERE id = %s', (new_id, url.id)) - cursor.update_auto_increment(cls._table, new_id) - url = cls(new_id) - cls.write([url], later) - return url + def create(cls, vlist): + new_vlist = [] + for vals in vlist: + later = {} + vals = vals.copy() + for field in vals: + if (field in cls._fields + and hasattr(cls._fields[field], 'set')): + later[field] = vals[field] + for field in later: + del vals[field] + cursor = Transaction().cursor + if cursor.nextid(cls._table): + cursor.setnextid(cls._table, cursor.currid('ir_action')) + url, = super(ActionURL, cls).create([vals]) + cursor.execute('SELECT action FROM "' + cls._table + '" ' + 'WHERE id = %s', (url.id,)) + new_id, = cursor.fetchone() + cls.write([url], {}) # simulate write to clear the cache + cursor.execute('UPDATE "' + cls._table + '" SET id = %s ' + 'WHERE id = %s', (new_id, url.id)) + cursor.update_auto_increment(cls._table, new_id) + url = cls(new_id) + new_vlist.append(url) + cls.write([url], later) + return new_vlist @classmethod def write(cls, urls, values): diff --git a/trytond/ir/attachment.py b/trytond/ir/attachment.py index fe969bd6a8..09c4d72797 100644 --- a/trytond/ir/attachment.py +++ b/trytond/ir/attachment.py @@ -227,10 +227,10 @@ class Attachment(ModelSQL, ModelView): cls.check_access(attachments, mode='write') @classmethod - def create(cls, vals): - attachment = super(Attachment, cls).create(vals) - cls.check_access([attachment.id], mode='create') - return attachment + def create(cls, vlist): + attachments = super(Attachment, cls).create(vlist) + cls.check_access([a.id for a in attachments], mode='create') + return attachments @classmethod def view_header_get(cls, value, view_type='form'): diff --git a/trytond/ir/cron.py b/trytond/ir/cron.py index a03002d4d1..c3630cb482 100644 --- a/trytond/ir/cron.py +++ b/trytond/ir/cron.py @@ -135,9 +135,9 @@ class Cron(ModelSQL, ModelView): 'body': body, 'date_sent': datetime.datetime.now(), 'references': [ - ('create', { - 'reference': '%s,%s' % (cls.__name__, cron.id), - }), + ('create', [{ + 'reference': '%s,%s' % (cls.__name__, cron.id), + }]), ], 'state': 'waiting', 'trigger_date': datetime.datetime.now(), @@ -163,7 +163,7 @@ class Cron(ModelSQL, ModelView): with contextlib.nested(Transaction().set_user(cron.user.id), Transaction().set_context(language=language)): values = cls._get_request_values(cron) - Request.create(values) + Request.create([values]) Transaction().cursor.commit() @classmethod diff --git a/trytond/ir/lang.py b/trytond/ir/lang.py index 6dc890a2b2..828232fc48 100644 --- a/trytond/ir/lang.py +++ b/trytond/ir/lang.py @@ -196,10 +196,10 @@ class Lang(ModelSQL, ModelView): return res @classmethod - def create(cls, vals): + def create(cls, vlist): # Clear cache cls._lang_cache.clear() - return super(Lang, cls).create(vals) + return super(Lang, cls).create(vlist) @classmethod def write(cls, langs, vals): diff --git a/trytond/ir/model.py b/trytond/ir/model.py index 9a11bef363..22fb691e50 100644 --- a/trytond/ir/model.py +++ b/trytond/ir/model.py @@ -90,10 +90,10 @@ class Model(ModelSQL, ModelView): return [m.model for m in models] @classmethod - def create(cls, vals): + def create(cls, vlist): pool = Pool() Property = pool.get('ir.property') - res = super(Model, cls).create(vals) + res = super(Model, cls).create(vlist) # Restart the cache of models_get Property._models_get_cache.clear() return res @@ -415,8 +415,8 @@ class ModelAccess(ModelSQL, ModelView): ModelView._fields_view_get_cache.clear() @classmethod - def create(cls, vals): - res = super(ModelAccess, cls).create(vals) + def create(cls, vlist): + res = super(ModelAccess, cls).create(vlist) # Restart the cache cls._get_access_cache.clear() ModelView._fields_view_get_cache.clear() @@ -556,8 +556,8 @@ class ModelFieldAccess(ModelSQL, ModelView): ModelView._fields_view_get_cache.clear() @classmethod - def create(cls, vals): - res = super(ModelFieldAccess, cls).create(vals) + def create(cls, vlist): + res = super(ModelFieldAccess, cls).create(vlist) # Restart the cache cls._get_access_cache.clear() ModelView._fields_view_get_cache.clear() @@ -591,8 +591,8 @@ class ModelButton(ModelSQL, ModelView): cls._order.insert(0, ('model', 'ASC')) @classmethod - def create(cls, values): - result = super(ModelButton, cls).create(values) + def create(cls, vlist): + result = super(ModelButton, cls).create(vlist) # Restart the cache for get_groups cls._groups_cache.clear() return result diff --git a/trytond/ir/module/module.py b/trytond/ir/module/module.py index b2e20d5b8b..40f4a271e7 100644 --- a/trytond/ir/module/module.py +++ b/trytond/ir/module/module.py @@ -255,10 +255,10 @@ class Module(ModelSQL, ModelView): tryton = get_module_info(name) if not tryton: continue - module = cls.create({ - 'name': name, - 'state': 'uninstalled', - }) + module, = cls.create([{ + 'name': name, + 'state': 'uninstalled', + }]) count += 1 cls._update_dependencies(module, tryton.get('depends', [])) return count @@ -274,12 +274,15 @@ class Module(ModelSQL, ModelView): # Restart Browse Cache for deleted dependencies module = cls(module.id) dependency_names = [x.name for x in module.dependencies] + to_create = [] for depend in depends: if depend not in dependency_names: - Dependency.create({ + to_create.append({ 'module': module.id, 'name': depend, }) + if to_create: + Dependency.create(to_create) class ModuleDependency(ModelSQL, ModelView): diff --git a/trytond/ir/property.py b/trytond/ir/property.py index c8bf83e28e..4d82923ec3 100644 --- a/trytond/ir/property.py +++ b/trytond/ir/property.py @@ -157,4 +157,4 @@ class Property(ModelSQL, ModelView): for res_id in ids: vals = cls._set_values(model, res_id, val, model_field.id) with Transaction().set_user(0, set_context=True): - cls.create(vals).id + cls.create([vals]) diff --git a/trytond/ir/rule.py b/trytond/ir/rule.py index 1046fd4b5e..9ec69a8e92 100644 --- a/trytond/ir/rule.py +++ b/trytond/ir/rule.py @@ -79,8 +79,8 @@ class RuleGroup(ModelSQL, ModelView): Pool().get('ir.rule')._domain_get_cache.clear() @classmethod - def create(cls, vals): - res = super(RuleGroup, cls).create(vals) + def create(cls, vlist): + res = super(RuleGroup, cls).create(vlist) # Restart the cache on the domain_get method of ir.rule Pool().get('ir.rule')._domain_get_cache.clear() return res @@ -252,8 +252,8 @@ class Rule(ModelSQL, ModelView): cls._domain_get_cache.clear() @classmethod - def create(cls, vals): - res = super(Rule, cls).create(vals) + def create(cls, vlist): + res = super(Rule, cls).create(vlist) # Restart the cache on the domain_get method of ir.rule cls._domain_get_cache.clear() return res diff --git a/trytond/ir/sequence.py b/trytond/ir/sequence.py index 13f9daf2f1..1bfff43bb2 100644 --- a/trytond/ir/sequence.py +++ b/trytond/ir/sequence.py @@ -2,6 +2,7 @@ #this repository contains the full copyright notices and license terms. from string import Template import time +from itertools import izip from ..model import ModelView, ModelSQL, fields from ..tools import datetime_strftime from ..pyson import Eval, And @@ -171,13 +172,13 @@ class Sequence(ModelSQL, ModelView): }) @classmethod - def create(cls, values): - sequence_id = super(Sequence, cls).create(values) - if sql_sequence and not cls._strict: - sequence = cls(sequence_id) - sequence.update_sql_sequence(values.get('number_next', - cls.default_number_next())) - return sequence_id + def create(cls, vlist): + sequences = super(Sequence, cls).create(vlist) + for sequence, values in izip(sequences, vlist): + if sql_sequence and not cls._strict: + sequence.update_sql_sequence(values.get('number_next', + cls.default_number_next())) + return sequences @classmethod def write(cls, sequences, values): diff --git a/trytond/ir/translation.py b/trytond/ir/translation.py index 11736c3572..57012e4041 100644 --- a/trytond/ir/translation.py +++ b/trytond/ir/translation.py @@ -278,14 +278,14 @@ class Translation(ModelSQL, ModelView): ]) with Transaction().set_user(0): if not translation2: - cls.create({ - 'name': name, - 'lang': lang, - 'type': ttype, - 'src': getattr(record, field_name), - 'value': value, - 'fuzzy': False, - }) + cls.create([{ + 'name': name, + 'lang': lang, + 'type': ttype, + 'src': getattr(record, field_name), + 'value': value, + 'fuzzy': False, + }]) else: cls.write(translation2, { 'src': getattr(record, field_name), @@ -305,15 +305,15 @@ class Translation(ModelSQL, ModelView): ]) with Transaction().set_user(0): if not translation2: - cls.create({ - 'name': name, - 'lang': lang, - 'type': ttype, - 'res_id': record.id, - 'value': value, - 'src': getattr(record, field_name), - 'fuzzy': False, - }) + cls.create([{ + 'name': name, + 'lang': lang, + 'type': ttype, + 'res_id': record.id, + 'value': value, + 'src': getattr(record, field_name), + 'fuzzy': False, + }]) else: cls.write(translation2, { 'value': value, @@ -462,43 +462,43 @@ class Translation(ModelSQL, ModelView): return super(Translation, cls).delete(translations) @classmethod - def create(cls, vals): + def create(cls, vlist): cls._translation_cache.clear() ModelView._fields_view_get_cache.clear() + vlist = [x.copy() for x in vlist] + cursor = Transaction().cursor - if not vals.get('module'): - if Transaction().context.get('module'): - vals = vals.copy() - vals['module'] = Transaction().context['module'] - elif vals.get('type', '') in ('odt', 'view', 'wizard_button', - 'selection', 'error'): - cursor.execute('SELECT module FROM ir_translation ' - 'WHERE name = %s ' - 'AND res_id = %s ' - 'AND lang = %s ' - 'AND type = %s ' - 'AND src = %s ', - (vals.get('name') or '', vals.get('res_id') or 0, 'en_US', - vals.get('type') or '', vals.get('src') or '')) - fetchone = cursor.fetchone() - if fetchone: - vals = vals.copy() - vals['module'] = fetchone[0] - else: - cursor.execute('SELECT module, src FROM ir_translation ' - 'WHERE name = %s ' - 'AND res_id = %s ' - 'AND lang = %s ' - 'AND type = %s', - (vals.get('name') or '', vals.get('res_id') or 0, 'en_US', - vals.get('type') or '')) - fetchone = cursor.fetchone() - if fetchone: - vals = vals.copy() - vals['module'], vals['src'] = fetchone - vals = vals.copy() - vals['src_md5'] = cls.get_src_md5(vals.get('src')) - return super(Translation, cls).create(vals) + for vals in vlist: + if not vals.get('module'): + if Transaction().context.get('module'): + vals['module'] = Transaction().context['module'] + elif vals.get('type', '') in ('odt', 'view', 'wizard_button', + 'selection', 'error'): + cursor.execute('SELECT module FROM ir_translation ' + 'WHERE name = %s ' + 'AND res_id = %s ' + 'AND lang = %s ' + 'AND type = %s ' + 'AND src = %s ', + (vals.get('name') or '', vals.get('res_id') or 0, + 'en_US', vals.get('type') or '', vals.get('src') + or '')) + fetchone = cursor.fetchone() + if fetchone: + vals['module'] = fetchone[0] + else: + cursor.execute('SELECT module, src FROM ir_translation ' + 'WHERE name = %s ' + 'AND res_id = %s ' + 'AND lang = %s ' + 'AND type = %s', + (vals.get('name') or '', vals.get('res_id') or 0, + 'en_US', vals.get('type') or '')) + fetchone = cursor.fetchone() + if fetchone: + vals['module'], vals['src'] = fetchone + vals['src_md5'] = cls.get_src_md5(vals.get('src')) + return super(Translation, cls).create(vlist) @classmethod def write(cls, translations, vals): @@ -522,6 +522,7 @@ class Translation(ModelSQL, ModelView): fs_id2model_data[model_data.model][model_data.fs_id] = model_data translations = set() + to_create = [] pofile = polib.pofile(po_path) id2translation = {} @@ -575,7 +576,7 @@ class Translation(ModelSQL, ModelView): with contextlib.nested(Transaction().set_user(0), Transaction().set_context(module=module)): if not ids: - translations.add(cls.create({ + to_create.append({ 'name': name, 'res_id': res_id, 'lang': lang, @@ -584,7 +585,7 @@ class Translation(ModelSQL, ModelView): 'value': value, 'fuzzy': fuzzy, 'module': module, - })) + }) else: translations2 = [] for translation_id in ids: @@ -599,6 +600,9 @@ class Translation(ModelSQL, ModelView): }) translations |= set(cls.browse(ids)) + if to_create: + translations |= set(cls.create(to_create)) + if translations: all_translations = set(cls.search([ ('module', '=', module), @@ -1063,16 +1067,19 @@ class TranslationUpdate(Wizard): 'AND type in (\'odt\', \'view\', \'wizard_button\', ' \ ' \'selection\', \'error\')', (lang,)) + to_create = [] for row in cursor.dictfetchall(): + to_create.append({ + 'name': row['name'], + 'res_id': row['res_id'], + 'lang': lang, + 'type': row['type'], + 'src': row['src'], + 'module': row['module'], + }) + if to_create: with Transaction().set_user(0): - Translation.create({ - 'name': row['name'], - 'res_id': row['res_id'], - 'lang': lang, - 'type': row['type'], - 'src': row['src'], - 'module': row['module'], - }) + Translation.create(to_create) cursor.execute('SELECT name, res_id, type, module ' \ 'FROM ir_translation ' \ 'WHERE lang=\'en_US\' ' \ @@ -1082,15 +1089,18 @@ class TranslationUpdate(Wizard): 'WHERE lang=%s ' \ 'AND type in (\'field\', \'model\', \'help\')', (lang,)) + to_create = [] for row in cursor.dictfetchall(): + to_create.append({ + 'name': row['name'], + 'res_id': row['res_id'], + 'lang': lang, + 'type': row['type'], + 'module': row['module'], + }) + if to_create: with Transaction().set_user(0): - Translation.create({ - 'name': row['name'], - 'res_id': row['res_id'], - 'lang': lang, - 'type': row['type'], - 'module': row['module'], - }) + Translation.create(to_create) cursor.execute('SELECT name, res_id, type, src ' \ 'FROM ir_translation ' \ 'WHERE lang=\'en_US\' ' \ diff --git a/trytond/ir/trigger.py b/trytond/ir/trigger.py index e8da5d4e8a..d0a3494daf 100644 --- a/trytond/ir/trigger.py +++ b/trytond/ir/trigger.py @@ -223,11 +223,14 @@ class Trigger(ModelSQL, ModelView): if records: getattr(Model, trigger.action_function)(records, trigger) if trigger.limit_number or trigger.minimum_delay: + to_create = [] for record in records: - TriggerLog.create({ - 'trigger': trigger.id, - 'record_id': record.id, - }) + to_create.append({ + 'trigger': trigger.id, + 'record_id': record.id, + }) + if to_create: + TriggerLog.create(to_create) @classmethod def trigger_time(cls): @@ -250,8 +253,8 @@ class Trigger(ModelSQL, ModelView): cls.trigger_action(triggered, trigger) @classmethod - def create(cls, values): - res = super(Trigger, cls).create(values) + def create(cls, vlist): + res = super(Trigger, cls).create(vlist) # Restart the cache on the get_triggers method of ir.trigger cls._get_triggers_cache.clear() return res diff --git a/trytond/ir/ui/menu.py b/trytond/ir/ui/menu.py index 0186c59aca..e0a253e0a0 100644 --- a/trytond/ir/ui/menu.py +++ b/trytond/ir/ui/menu.py @@ -225,13 +225,16 @@ class UIMenu(ModelSQL, ModelView): return Action = pool.get(action_type) action = Action(int(action_id)) + to_create = [] for menu in menus: with Transaction().set_context(_timestamp=False): - ActionKeyword.create({ - 'keyword': 'tree_open', - 'model': str(menu), - 'action': action.action.id, - }) + to_create.append({ + 'keyword': 'tree_open', + 'model': str(menu), + 'action': action.action.id, + }) + if to_create: + ActionKeyword.create(to_create) @classmethod def get_favorite(cls, menus, name): @@ -288,10 +291,10 @@ class UIMenuFavorite(ModelSQL, ModelView): @classmethod def set(cls, menu_id): user = Transaction().user - cls.create({ - 'menu': menu_id, - 'user': user, - }) + cls.create([{ + 'menu': menu_id, + 'user': user, + }]) @classmethod def unset(cls, menu_id): diff --git a/trytond/ir/ui/view.py b/trytond/ir/ui/view.py index aafaf850f8..359442174d 100644 --- a/trytond/ir/ui/view.py +++ b/trytond/ir/ui/view.py @@ -257,11 +257,11 @@ class View(ModelSQL, ModelView): ModelView._fields_view_get_cache.clear() @classmethod - def create(cls, vals): - view = super(View, cls).create(vals) + def create(cls, vlist): + views = super(View, cls).create(vlist) # Restart the cache ModelView._fields_view_get_cache.clear() - return view + return views @classmethod def write(cls, views, vals): @@ -336,8 +336,8 @@ class ViewTreeWidth(ModelSQL, ModelView): super(ViewTreeWidth, cls).delete(records) @classmethod - def create(cls, vals): - res = super(ViewTreeWidth, cls).create(vals) + def create(cls, vlist): + res = super(ViewTreeWidth, cls).create(vlist) ModelView._fields_view_get_cache.clear() return res @@ -359,13 +359,16 @@ class ViewTreeWidth(ModelSQL, ModelView): ]) cls.delete(records) + to_create = [] for field in fields.keys(): - cls.create({ - 'model': model, - 'field': field, - 'user': Transaction().user, - 'width': fields[field], - }) + to_create.append({ + 'model': model, + 'field': field, + 'user': Transaction().user, + 'width': fields[field], + }) + if to_create: + cls.create(to_create) class ViewTreeExpandedState(ModelSQL, ModelView): @@ -410,13 +413,13 @@ class ViewTreeExpandedState(ModelSQL, ModelView): ('child_name', '=', child_name), ]) cls.delete(records) - cls.create({ - 'user': current_user, - 'model': model, - 'domain': domain, - 'child_name': child_name, - 'nodes': nodes, - }) + cls.create([{ + 'user': current_user, + 'model': model, + 'domain': domain, + 'child_name': child_name, + 'nodes': nodes, + }]) @classmethod def get_expanded(cls, model, domain, child_name): diff --git a/trytond/model/fields/many2many.py b/trytond/model/fields/many2many.py index f5c15a0d4e..5c92047c9c 100644 --- a/trytond/model/fields/many2many.py +++ b/trytond/model/fields/many2many.py @@ -102,7 +102,7 @@ class Many2Many(Field): Set the values. values: A list of tuples: - (``create``, ``{: value}``), + (``create``, ``[{: value}, ...]``), (``write``, ````, ``{: value}``), (``delete``, ````), (``delete_all``), @@ -116,7 +116,6 @@ class Many2Many(Field): return Relation = pool.get(self.relation_name) Target = self.get_target() - if self.origin in Relation._fields: origin_field = Relation._fields[self.origin] else: @@ -137,11 +136,15 @@ class Many2Many(Field): for act in values: if act[0] == 'create': + to_create = [] for record_id in ids: - Relation.create({ - self.origin: field_value(record_id), - self.target: Target.create(act[1]).id, - }) + for new in Target.create(act[1]): + to_create.append({ + self.origin: field_value(record_id), + self.target: new.id, + }) + if to_create: + Relation.create(to_create) elif act[0] == 'write': Target.write(Target.browse(act[1]), act[2]) elif act[0] == 'delete': @@ -182,12 +185,15 @@ class Many2Many(Field): ]) for relation in relations: existing_ids.append(getattr(relation, self.target).id) + to_create = [] for new_id in (x for x in target_ids if x not in existing_ids): for record_id in ids: - Relation.create({ + to_create.append({ self.origin: field_value(record_id), self.target: new_id, }) + if to_create: + Relation.create(to_create) elif act[0] == 'unlink_all': targets = Relation.search([ search_clause(ids), @@ -205,12 +211,15 @@ class Many2Many(Field): ]) Relation.delete(targets2) + to_create = [] for new_id in target_ids: for record_id in ids: - Relation.create({ + to_create.append({ self.origin: field_value(record_id), self.target: new_id, }) + if to_create: + Relation.create(to_create) else: raise Exception('Bad arguments') diff --git a/trytond/model/fields/one2many.py b/trytond/model/fields/one2many.py index af588054e9..0ec20f99fa 100644 --- a/trytond/model/fields/one2many.py +++ b/trytond/model/fields/one2many.py @@ -107,7 +107,7 @@ class One2Many(Field): ''' Set the values. values: A list of tuples: - (``create``, ``{: value}``), + (``create``, ``[{: value}, ...]``), (``write``, ````, ``{: value}``), (``delete``, ````), (``delete_all``), @@ -139,9 +139,15 @@ class One2Many(Field): for act in values: if act[0] == 'create': + to_create = [] for record_id in ids: - act[1][self.field] = field_value(record_id) - Target.create(act[1]) + value = field_value(record_id) + for vals in act[1]: + vals = vals.copy() + vals[self.field] = value + to_create.append(vals) + if to_create: + Target.create(to_create) elif act[0] == 'write': Target.write(Target.browse(act[1]), act[2]) elif act[0] == 'delete': diff --git a/trytond/model/fields/one2one.py b/trytond/model/fields/one2one.py index e01cfc714a..eea5ac8168 100644 --- a/trytond/model/fields/one2one.py +++ b/trytond/model/fields/one2one.py @@ -44,11 +44,14 @@ class One2One(Many2Many): ]) Relation.delete(relations) if value: + to_create = [] for record_id in ids: - Relation.create({ + to_create.append({ self.origin: record_id, self.target: value, }) + if to_create: + Relation.create(to_create) def __set__(self, inst, value): Target = self.get_target() diff --git a/trytond/model/modelsingleton.py b/trytond/model/modelsingleton.py index 3f2af20260..6da16ce95e 100644 --- a/trytond/model/modelsingleton.py +++ b/trytond/model/modelsingleton.py @@ -18,13 +18,13 @@ class ModelSingleton(ModelStorage): return singletons[0] @classmethod - def create(cls, values): + def create(cls, vlist): + assert len(vlist) == 1 singleton = cls.get_singleton() - if singleton: - cls.write([singleton], values) - else: - singleton = super(ModelSingleton, cls).create(values) - return singleton + if not singleton: + return super(ModelSingleton, cls).create(vlist) + cls.write([singleton], vlist[0]) + return [singleton] @classmethod def read(cls, ids, fields_names=None): @@ -48,7 +48,7 @@ class ModelSingleton(ModelStorage): def write(cls, records, values): singleton = cls.get_singleton() if not singleton: - return cls.create(values) + return cls.create([values]) return super(ModelSingleton, cls).write([singleton], values) @classmethod diff --git a/trytond/model/modelsql.py b/trytond/model/modelsql.py index 6303dc1be5..26c172f257 100644 --- a/trytond/model/modelsql.py +++ b/trytond/model/modelsql.py @@ -5,7 +5,7 @@ import datetime import re from functools import reduce from decimal import Decimal -from itertools import islice +from itertools import islice, izip from trytond.model import ModelStorage from trytond.model import fields @@ -220,186 +220,212 @@ class ModelSQL(ModelStorage): return None @classmethod - def create(cls, values): - super(ModelSQL, cls).create(values) + def create(cls, vlist): + super(ModelSQL, cls).create(vlist) cursor = Transaction().cursor pool = Pool() if cls.table_query(): return False - values = values.copy() + modified_fields = set() + new_ids = [] + vlist = [v.copy() for v in vlist] + for values in vlist: + # Clean values + for key in ('create_uid', 'create_date', 'write_uid', 'write_date', + 'id'): + if key in values: + del values[key] + modified_fields |= set(values.keys()) - # Clean values - for key in ('create_uid', 'create_date', 'write_uid', 'write_date', - 'id'): - if key in values: - del values[key] + # Get default values + default = [] + avoid_table = [] + for (i, j) in cls._inherits.items(): + if j in values: + avoid_table.append(i) + for i in cls._fields.keys(): + if not i in values \ + and i not in ('create_uid', 'create_date', + 'write_uid', 'write_date'): + default.append(i) + for i in cls._inherit_fields.keys(): + if ((not i in values) + and (not cls._inherit_fields[i][0] in avoid_table) + and i in cls._defaults): + default.append(i) - # Get default values - default = [] - avoid_table = [] - for (i, j) in cls._inherits.items(): - if j in values: - avoid_table.append(i) - for i in cls._fields.keys(): - if not i in values \ - and i not in ('create_uid', 'create_date', + if len(default): + defaults = cls.default_get(default, with_rec_name=False) + for field in defaults.keys(): + if '.' in field: + del defaults[field] + if field in ('create_uid', 'create_date', 'write_uid', 'write_date'): - default.append(i) - for i in cls._inherit_fields.keys(): - if ((not i in values) - and (not cls._inherit_fields[i][0] in avoid_table) - and i in cls._defaults): - default.append(i) + del defaults[field] + if field in values: + del defaults[field] + values.update(cls._clean_defaults(defaults)) - if len(default): - defaults = cls.default_get(default, with_rec_name=False) - for field in defaults.keys(): - if '.' in field: - del defaults[field] - if field in ('create_uid', 'create_date', - 'write_uid', 'write_date'): - del defaults[field] - if field in values: - del defaults[field] - values.update(cls._clean_defaults(defaults)) + (upd0, upd1, upd2) = ('', '', []) + upd_todo = [] - (upd0, upd1, upd2) = ('', '', []) - upd_todo = [] + # Create inherits + tocreate = {} + for i in cls._inherits: + if cls._inherits[i] not in values: + tocreate[i] = {} - # Create inherits - tocreate = {} - for i in cls._inherits: - if cls._inherits[i] not in values: - tocreate[i] = {} + for i in values.keys(): + if i in cls._inherit_fields: + (inherits, _, _) = cls._inherit_fields[i] + if i in cls._fields: + continue + if inherits in tocreate: + tocreate[inherits][i] = values[i] + del values[i] - for i in values.keys(): - if i in cls._inherit_fields: - (inherits, _, _) = cls._inherit_fields[i] - if i in cls._fields: - continue - if inherits in tocreate: - tocreate[inherits][i] = values[i] - del values[i] + for inherits in tocreate: + Inherits = pool.get(inherits) + inherits_record, = Inherits.create([tocreate[inherits]]) + values[cls._inherits[inherits]] = inherits_record.id - for inherits in tocreate: - Inherits = pool.get(inherits) - inherits_record = Inherits.create(tocreate[inherits]) - values[cls._inherits[inherits]] = inherits_record.id - - # Insert record - for fname, value in values.iteritems(): - field = cls._fields[fname] - if not hasattr(field, 'set'): - upd0 = upd0 + ',"' + fname + '"' - upd1 = upd1 + ', %s' - upd2.append(FIELDS[field._type].sql_format(value)) - else: - upd_todo.append(fname) - upd0 += ', create_uid, create_date' - upd1 += ', %s, %s' - upd2.append(Transaction().user) - upd2.append(datetime.datetime.now()) - try: - if cursor.has_returning(): - cursor.execute('INSERT INTO "' + cls._table + '" ' - '(' + upd0[1:] + ') ' - 'VALUES (' + upd1[1:] + ') RETURNING id', - tuple(upd2)) - id_new, = cursor.fetchone() - else: - id_new = cursor.nextid(cls._table) - if id_new: - cursor.execute('INSERT INTO "' + cls._table + '" ' - '(id' + upd0 + ') ' - 'VALUES (' + str(id_new) + upd1 + ')', - tuple(upd2)) + # Insert record + for fname, value in values.iteritems(): + field = cls._fields[fname] + if not hasattr(field, 'set'): + upd0 = upd0 + ',"' + fname + '"' + upd1 = upd1 + ', %s' + upd2.append(FIELDS[field._type].sql_format(value)) else: + upd_todo.append(fname) + upd0 += ', create_uid, create_date' + upd1 += ', %s, %s' + upd2.append(Transaction().user) + upd2.append(datetime.datetime.now()) + + try: + if cursor.has_returning(): cursor.execute('INSERT INTO "' + cls._table + '" ' '(' + upd0[1:] + ') ' - 'VALUES (' + upd1[1:] + ')', + 'VALUES (' + upd1[1:] + ') RETURNING id', tuple(upd2)) - id_new = cursor.lastid() - except DatabaseIntegrityError, exception: - with contextlib.nested(Transaction().new_cursor(), - Transaction().set_user(0)): - for field_name in cls._fields: - field = cls._fields[field_name] - # Check required fields - if field.required and \ - not hasattr(field, 'set') and \ - field_name not in ('create_uid', 'create_date'): - if values.get(field_name) is None: - cls.raise_user_error('required_field', - error_args=cls._get_error_args( - field_name)) - if isinstance(field, fields.Many2One) \ - and values.get(field_name): - Model = pool.get(field.model_name) - create_records = Transaction().create_records.get( - field.model_name, set()) - delete_records = Transaction().delete_records.get( - field.model_name, set()) - if not ((Model.search([ - ('id', '=', values[field_name]), - ], order=[]) - or values[field_name] in create_records) - and values[field_name] not in delete_records): - cls.raise_user_error('foreign_model_missing', - error_args=cls._get_error_args( - field_name)) - for name, _, error in cls._sql_constraints: - if name in exception[0]: - cls.raise_user_error(error) - for name, error in cls._sql_error_messages: - if name in exception[0]: - cls.raise_user_error(error) - raise + id_new, = cursor.fetchone() + else: + id_new = cursor.nextid(cls._table) + if id_new: + cursor.execute('INSERT INTO "' + cls._table + '" ' + '(id' + upd0 + ') ' + 'VALUES (' + str(id_new) + upd1 + ')', + tuple(upd2)) + else: + cursor.execute('INSERT INTO "' + cls._table + '" ' + '(' + upd0[1:] + ') ' + 'VALUES (' + upd1[1:] + ')', + tuple(upd2)) + id_new = cursor.lastid() + new_ids.append(id_new) + except DatabaseIntegrityError, exception: + with contextlib.nested(Transaction().new_cursor(), + Transaction().set_user(0)): + for field_name in cls._fields: + field = cls._fields[field_name] + # Check required fields + if field.required and \ + not hasattr(field, 'set') and \ + field_name not in ('create_uid', 'create_date'): + if values.get(field_name) is None: + cls.raise_user_error('required_field', + error_args=cls._get_error_args( + field_name)) + if isinstance(field, fields.Many2One) \ + and values.get(field_name): + Model = pool.get(field.model_name) + create_records = Transaction().create_records.get( + field.model_name, set()) + delete_records = Transaction().delete_records.get( + field.model_name, set()) + if not ((Model.search([ + ('id', '=', values[field_name]), + ], order=[]) + or values[field_name] in create_records) + and values[field_name] not in + delete_records): + cls.raise_user_error('foreign_model_missing', + error_args=cls._get_error_args( + field_name)) + for name, _, error in cls._sql_constraints: + if name in exception[0]: + cls.raise_user_error(error) + for name, error in cls._sql_error_messages: + if name in exception[0]: + cls.raise_user_error(error) + raise domain1, domain2 = pool.get('ir.rule').domain_get(cls.__name__, mode='create') if domain1: - cursor.execute('SELECT id FROM "' + cls._table + '" ' \ - 'WHERE id = %s AND (' + domain1 + ')', - [id_new] + domain2) - if not cursor.fetchone(): - cls.raise_user_error('access_error', cls.__name__) + in_max = Transaction().cursor.IN_MAX + for i in range(0, len(new_ids), in_max): + sub_ids = new_ids[i:i + in_max] + red_sql, red_ids = reduce_ids('id', sub_ids) - Transaction().create_records.setdefault( - cls.__name__, set()).add(id_new) + cursor.execute('SELECT id FROM "' + cls._table + '" WHERE ' + + red_sql + ' AND (' + domain1 + ')', red_ids + domain2) + if len(cursor.fetchall()) != len(sub_ids): + cls.raise_user_error('access_error', cls.__name__) - for field in values: - if getattr(cls._fields[field], 'translate', False): - pool.get('ir.translation').set_ids( - cls.__name__ + ',' + field, 'model', - Transaction().language, [id_new], values[field]) + create_records = Transaction().create_records.setdefault(cls.__name__, + set()).update(new_ids) - for field in upd_todo: - cls._fields[field].set([id_new], cls, field, values[field]) + for values, new_id in izip(vlist, new_ids): + for field in values: + if getattr(cls._fields[field], 'translate', False): + pool.get('ir.translation').set_ids( + cls.__name__ + ',' + field, 'model', + Transaction().language, [new_id], values[field]) + + for field in upd_todo: + if field in values: + cls._fields[field].set([new_id], cls, field, values[field]) if cls._history: - cursor.execute('INSERT INTO "' + cls._table + '__history" ' - '(id' + upd0 + ') ' - 'SELECT id' + upd0 + ' ' - 'FROM "' + cls._table + '" ' - 'WHERE id = %s', (id_new,)) + columns = ['"' + str(x) + '"' for x in cls._fields + if not hasattr(cls._fields[x], 'set')] + columns = ','.join(columns) + for i in range(0, len(new_ids), cursor.IN_MAX): + sub_ids = new_ids[i:i + cursor.IN_MAX] + red_sql, red_ids = reduce_ids('id', sub_ids) + cursor.execute('INSERT INTO "' + cls._table + '__history" ' + '(' + columns + ') ' + 'SELECT ' + columns + ' ' + 'FROM "' + cls._table + '" ' + 'WHERE ' + red_sql, red_ids) - record = cls(id_new) - cls._validate([record]) + records = cls.browse(new_ids) + cls._validate(records) # Check for Modified Preorder Tree Traversal for k in cls._fields: field = cls._fields[k] - if isinstance(field, fields.Many2One) \ - and field.model_name == cls.__name__ \ - and field.left and field.right: - cls._update_tree(id_new, k, field.left, field.right) - - cls.trigger_create(record) - - return record + if (isinstance(field, fields.Many2One) + and field.model_name == cls.__name__ + and field.left and field.right): + if (field.left in modified_fields + or field.right in modified_fields): + raise Exception('ValidateError', + 'You can not update fields: "%s", "%s"' % + (field.left, field.right)) + if len(new_ids) == 1: + cls._update_tree(new_ids[0], k, field.left, field.right) + else: + with Transaction().set_user(0): + cls._rebuild_tree(k, False, 0) + cls.trigger_create(records) + return records + @classmethod def read(cls, ids, fields_names=None): pool = Pool() diff --git a/trytond/model/modelstorage.py b/trytond/model/modelstorage.py index 5114d59d28..7d7b71b59c 100644 --- a/trytond/model/modelstorage.py +++ b/trytond/model/modelstorage.py @@ -14,7 +14,7 @@ except ImportError: import StringIO from decimal import Decimal -from itertools import islice, ifilter, ifilterfalse, chain +from itertools import islice, ifilter, ifilterfalse, chain, izip from functools import reduce from trytond.model import Model @@ -49,7 +49,7 @@ class ModelStorage(Model): super(ModelStorage, cls).__setup__() if issubclass(cls, ModelView): cls.__rpc__.update({ - 'create': RPC(readonly=False, result=int), + 'create': RPC(readonly=False, result=lambda r: map(int, r)), 'read': RPC(), 'write': RPC(readonly=False, instantiate=0), 'delete': RPC(readonly=False, instantiate=0), @@ -74,23 +74,24 @@ class ModelStorage(Model): return datetime.datetime.today() @classmethod - def create(cls, values): + def create(cls, vlist): ''' - Create record and return an instance. + Returns the list of created records. ''' pool = Pool() ModelAccess = pool.get('ir.model.access') ModelFieldAccess = pool.get('ir.model.field.access') ModelAccess.check(cls.__name__, 'create') - ModelFieldAccess.check(cls.__name__, - [x for x in values if x in cls._fields], 'write') + + all_fields = list(set(chain(*(v.iterkeys() for v in vlist)))) + ModelFieldAccess.check(cls.__name__, all_fields, 'write') # Increase transaction counter Transaction().counter += 1 @classmethod - def trigger_create(cls, record): + def trigger_create(cls, records): ''' Trigger create actions ''' @@ -99,8 +100,12 @@ class ModelStorage(Model): if not triggers: return for trigger in triggers: - if Trigger.eval(trigger, record): - Trigger.trigger_action([record], trigger) + triggers = [] + for record in records: + if Trigger.eval(trigger, record): + triggers.append(record) + if triggers: + Trigger.trigger_action(triggers, trigger) @classmethod def read(cls, ids, fields_names=None): @@ -281,21 +286,26 @@ class ModelStorage(Model): ids = map(int, records) datas = cls.read(ids, fields_names=fields_names) field_defs = cls.fields_get(fields_names=fields_names) + data_ids = [] + to_create = [] + o2m_to_create = [] for data in datas: - data_id = data['id'] + data_ids.append(data['id']) data, data_o2m = convert_data(field_defs, data) - new_record = cls.create(data) - if new_record: - new_ids[data_id] = new_record.id - else: - continue + to_create.append(data) + o2m_to_create.append(data_o2m) + if to_create: + new_records = cls.create(to_create) + for data_id, new_record, data_o2m in izip(data_ids, new_records, + o2m_to_create): + new_ids[data_id] = new_record.id for field_name in data_o2m: Relation = pool.get( field_defs[field_name]['relation']) relation_field = field_defs[field_name]['relation_field'] if relation_field: Relation.copy(Relation.browse(data_o2m[field_name]), - default={relation_field: new_ids[data_id]}) + default={relation_field: new_record.id}) fields_translate = {} for field_name, field in field_defs.iteritems(): @@ -709,7 +719,7 @@ class ModelStorage(Model): nbrmax = max(nbrmax, max2) reduce(lambda x, y: x and y, newrow) row[field] = (reduce(lambda x, y: x or y, newrow.values()) and - [('create', newrow)]) or [] + [('create', [newrow])]) or [] i = max2 while (position + i) < len(data): test = True @@ -724,7 +734,7 @@ class ModelStorage(Model): process_lines(data, prefix + [field], newfd, position + i) if reduce(lambda x, y: x or y, newrow.values()): - row[field].append(('create', newrow)) + row[field].append(('create', [newrow])) i += max2 nbrmax = max(nbrmax, i) if prefix_len == 0: @@ -756,7 +766,7 @@ class ModelStorage(Model): # XXX should raise Exception Transaction().cursor.rollback() return (-1, res, warning, '') - new_id = cls.create(res) + new_id, = cls.create([res]) for lang in translate: with Transaction().set_context(language=lang): cls.write(new_id, translate[lang]) @@ -1128,7 +1138,7 @@ class ModelStorage(Model): vals[field] = [] for defaults2 in defaults[field]: vals2 = obj._clean_defaults(defaults2) - vals[field].append(('create', vals2)) + vals[field].append(('create', [vals2])) elif fld_def._type in ('many2many',): vals[field] = [('set', defaults[field])] elif fld_def._type in ('boolean',): @@ -1366,7 +1376,7 @@ class ModelStorage(Model): ] for target in targets: if target.id < 0: - value.append(('create', target._save_values)) + value.append(('create', [target._save_values])) elif target._save_values: value.append( ('write', [target.id], target._save_values)) @@ -1383,7 +1393,7 @@ class ModelStorage(Model): if self.id < 0: self._ids.remove(self.id) try: - self.id = self.create(self._save_values).id + self.id = self.create([self._save_values])[0].id finally: self._ids.append(self.id) else: diff --git a/trytond/res/group.py b/trytond/res/group.py index 9f6c0865ee..2d4ce47ac7 100644 --- a/trytond/res/group.py +++ b/trytond/res/group.py @@ -73,8 +73,8 @@ class Group(ModelSQL, ModelView): return new_groups @classmethod - def create(cls, vals): - res = super(Group, cls).create(vals) + def create(cls, vlist): + res = super(Group, cls).create(vlist) pool = Pool() # Restart the cache on the domain_get method pool.get('ir.rule')._domain_get_cache.clear() diff --git a/trytond/res/ir.py b/trytond/res/ir.py index 8e16bc9e2c..29b93d6305 100644 --- a/trytond/res/ir.py +++ b/trytond/res/ir.py @@ -36,8 +36,8 @@ class UIMenuGroup(ModelSQL): super(UIMenuGroup, cls).__register__(module_name) @classmethod - def create(cls, vals): - res = super(UIMenuGroup, cls).create(vals) + def create(cls, vlist): + res = super(UIMenuGroup, cls).create(vlist) # Restart the cache on the domain_get method Pool().get('ir.rule')._domain_get_cache.clear() return res @@ -77,12 +77,13 @@ class ActionGroup(ModelSQL): super(ActionGroup, cls).__register__(module_name) @classmethod - def create(cls, vals): + def create(cls, vlist): Action = Pool().get('ir.action') - if vals.get('action'): - vals = vals.copy() - vals['action'] = Action.get_action_id(vals['action']) - res = super(ActionGroup, cls).create(vals) + vlist = [x.copy() for x in vlist] + for vals in vlist: + if vals.get('action'): + vals['action'] = Action.get_action_id(vals['action']) + res = super(ActionGroup, cls).create(vlist) # Restart the cache on the domain_get method Pool().get('ir.rule')._domain_get_cache.clear() return res @@ -137,9 +138,9 @@ class ModelButtonGroup(ModelSQL): return True @classmethod - def create(cls, values): + def create(cls, vlist): pool = Pool() - result = super(ModelButtonGroup, cls).create(values) + result = super(ModelButtonGroup, cls).create(vlist) # Restart the cache for get_groups pool.get('ir.model.button')._groups_cache.clear() return result @@ -238,9 +239,9 @@ class SequenceTypeGroup(ModelSQL): Rule._domain_get_cache.clear() @classmethod - def create(cls, vals): + def create(cls, vlist): Rule = Pool().get('ir.rule') - res = super(SequenceTypeGroup, cls).create(vals) + res = super(SequenceTypeGroup, cls).create(vlist) # Restart the cache on the domain_get method of ir.rule Rule._domain_get_cache.clear() return res @@ -295,10 +296,10 @@ class ModuleConfigWizardItem: __name__ = 'ir.module.module.config_wizard.item' @classmethod - def create(cls, values): + def create(cls, vlist): pool = Pool() User = pool.get('res.user') - result = super(ModuleConfigWizardItem, cls).create(values) + result = super(ModuleConfigWizardItem, cls).create(vlist) # Restart the cache for get_preferences User._get_preferences_cache.clear() return result diff --git a/trytond/res/request.py b/trytond/res/request.py index 21961df6d4..4151b504fd 100644 --- a/trytond/res/request.py +++ b/trytond/res/request.py @@ -116,6 +116,7 @@ class Request(ModelSQL, ModelView): def send(cls, requests): pool = Pool() RequestHistory = pool.get('res.request.history') + to_create = [] for request in requests: values = { 'request': request.id, @@ -131,7 +132,9 @@ class Request(ModelSQL, ModelView): values['name'] = values['body'][:125] + '...' else: values['name'] = values['body'] or '/' - RequestHistory.create(values) + to_create.append(values) + if to_create: + RequestHistory.create(to_create) cls.write(requests, { 'state': 'waiting', 'date_sent': datetime.datetime.now(), diff --git a/trytond/res/user.py b/trytond/res/user.py index 4d7bdc34e4..5dd7817bfd 100644 --- a/trytond/res/user.py +++ b/trytond/res/user.py @@ -211,9 +211,9 @@ class User(ModelSQL, ModelView): return vals @classmethod - def create(cls, vals): - vals = cls._convert_vals(vals) - res = super(User, cls).create(vals) + def create(cls, vlist): + vlist = [cls._convert_vals(vals) for vals in vlist] + res = super(User, cls).create(vlist) # Restart the cache for _get_login cls._get_login_cache.clear() return res @@ -495,9 +495,9 @@ class UserAction(ModelSQL): return values @classmethod - def create(cls, values): - values = cls._convert_values(values) - return super(UserAction, cls).create(values) + def create(cls, vlist): + vlist = [cls._convert_values(values) for values in vlist] + return super(UserAction, cls).create(vlist) @classmethod def write(cls, records, values): diff --git a/trytond/security.py b/trytond/security.py index 14729bcbce..75844bad83 100644 --- a/trytond/security.py +++ b/trytond/security.py @@ -25,7 +25,7 @@ def login(dbname, loginname, password, cache=True): return user_id with Transaction().start(dbname, user_id) as transaction: Session = pool.get('ir.session') - session = Session.create({}) + session, = Session.create([{}]) transaction.cursor.commit() return user_id, session.key return False diff --git a/trytond/tests/test_access.py b/trytond/tests/test_access.py index c4906bc80f..5695bcf83b 100644 --- a/trytond/tests/test_access.py +++ b/trytond/tests/test_access.py @@ -28,7 +28,7 @@ class ModelAccessTestCase(unittest.TestCase): context=CONTEXT) as transaction: model, = self.model.search([('model', '=', 'test.access')]) - test = self.test_access.create({}) + test, = self.test_access.create([{}]) # Without model access self.test_access.read([test.id]) @@ -36,11 +36,11 @@ class ModelAccessTestCase(unittest.TestCase): # With model access # One access allowed for any group - model_access_wo_group = self.model_access.create({ - 'model': model.id, - 'group': False, - 'perm_read': True, - }) + model_access_wo_group, = self.model_access.create([{ + 'model': model.id, + 'group': False, + 'perm_read': True, + }]) self.test_access.read([test.id]) # One access disallowed for any group @@ -51,11 +51,11 @@ class ModelAccessTestCase(unittest.TestCase): # Two access rules with one group allowed group, = self.group.search([('users', '=', USER)]) - model_access_w_group = self.model_access.create({ - 'model': model.id, - 'group': group.id, - 'perm_read': True, - }) + model_access_w_group, = self.model_access.create([{ + 'model': model.id, + 'group': group.id, + 'perm_read': True, + }]) self.test_access.read([test.id]) @@ -88,7 +88,7 @@ class ModelAccessTestCase(unittest.TestCase): self.test_access.read([test.id]) # One access allowed for one other group - group = self.group.create({'name': 'Test'}) + group, = self.group.create([{'name': 'Test'}]) self.model_access.write([model_access_w_group], { 'group': group.id, }) @@ -111,7 +111,7 @@ class ModelAccessTestCase(unittest.TestCase): context=CONTEXT) as transaction: model, = self.model.search([('model', '=', 'test.access')]) - test = self.test_access.create({}) + test, = self.test_access.create([{}]) # Without model access self.test_access.write([test], {}) @@ -119,11 +119,11 @@ class ModelAccessTestCase(unittest.TestCase): # With model access # One access allowed for any group - model_access_wo_group = self.model_access.create({ - 'model': model.id, - 'group': False, - 'perm_write': True, - }) + model_access_wo_group, = self.model_access.create([{ + 'model': model.id, + 'group': False, + 'perm_write': True, + }]) self.test_access.write([test], {}) # One access disallowed for any group @@ -134,11 +134,11 @@ class ModelAccessTestCase(unittest.TestCase): # Two access rules with one group allowed group, = self.group.search([('users', '=', USER)]) - model_access_w_group = self.model_access.create({ - 'model': model.id, - 'group': group.id, - 'perm_write': True, - }) + model_access_w_group, = self.model_access.create([{ + 'model': model.id, + 'group': group.id, + 'perm_write': True, + }]) self.test_access.write([test], {}) # Two access rules with both allowed @@ -170,7 +170,7 @@ class ModelAccessTestCase(unittest.TestCase): self.test_access.write([test], {}) # One access allowed for one other group - group = self.group.create({'name': 'Test'}) + group, = self.group.create([{'name': 'Test'}]) self.model_access.write([model_access_w_group], { 'group': group.id, }) @@ -194,17 +194,17 @@ class ModelAccessTestCase(unittest.TestCase): model, = self.model.search([('model', '=', 'test.access')]) # Without model access - self.test_access.create({}) + self.test_access.create([{}]) # With model access # One access allowed for any group - model_access_wo_group = self.model_access.create({ - 'model': model.id, - 'group': False, - 'perm_create': True, - }) - self.test_access.create({}) + model_access_wo_group, = self.model_access.create([{ + 'model': model.id, + 'group': False, + 'perm_create': True, + }]) + self.test_access.create([{}]) # One access disallowed for any group self.model_access.write([model_access_wo_group], { @@ -214,54 +214,54 @@ class ModelAccessTestCase(unittest.TestCase): # Two access rules with one group allowed group, = self.group.search([('users', '=', USER)]) - model_access_w_group = self.model_access.create({ - 'model': model.id, - 'group': group.id, - 'perm_create': True, - }) + model_access_w_group, = self.model_access.create([{ + 'model': model.id, + 'group': group.id, + 'perm_create': True, + }]) - self.test_access.create({}) + self.test_access.create([{}]) # Two access rules with both allowed self.model_access.write([model_access_wo_group], { 'perm_create': True, }) - self.test_access.create({}) + self.test_access.create([{}]) # Two access rules with any group allowed self.model_access.write([model_access_w_group], { 'perm_create': False, }) - self.test_access.create({}) + self.test_access.create([{}]) # Two access rules with both disallowed self.model_access.write([model_access_wo_group], { 'perm_create': False, }) - self.assertRaises(Exception, self.test_access.create, {}) + self.assertRaises(Exception, self.test_access.create, [{}]) # One access disallowed for one group self.model_access.delete([model_access_wo_group]) - self.assertRaises(Exception, self.test_access.create, {}) + self.assertRaises(Exception, self.test_access.create, [{}]) # One access allowed for one group self.model_access.write([model_access_w_group], { 'perm_create': True, }) - self.test_access.create({}) + self.test_access.create([{}]) # One access allowed for one other group - group = self.group.create({'name': 'Test'}) + group, = self.group.create([{'name': 'Test'}]) self.model_access.write([model_access_w_group], { 'group': group.id, }) - self.test_access.create({}) + self.test_access.create([{}]) # One access disallowed for one other group self.model_access.write([model_access_w_group], { 'perm_create': False, }) - self.test_access.create({}) + self.test_access.create([{}]) transaction.cursor.rollback() self.model_access._get_access_cache.clear() @@ -274,7 +274,7 @@ class ModelAccessTestCase(unittest.TestCase): context=CONTEXT) as transaction: model, = self.model.search([('model', '=', 'test.access')]) - tests = [self.test_access.create({}) for x in range(11)] + tests = [self.test_access.create([{}])[0] for x in range(11)] # Without model access self.test_access.delete([tests.pop()]) @@ -282,11 +282,11 @@ class ModelAccessTestCase(unittest.TestCase): # With model access # One access allowed for any group - model_access_wo_group = self.model_access.create({ - 'model': model.id, - 'group': False, - 'perm_delete': True, - }) + model_access_wo_group, = self.model_access.create([{ + 'model': model.id, + 'group': False, + 'perm_delete': True, + }]) self.test_access.delete([tests.pop()]) # One access disallowed for any group @@ -298,11 +298,11 @@ class ModelAccessTestCase(unittest.TestCase): # Two access rules with one group allowed group = self.group.search([('users', '=', USER)])[0] - model_access_w_group = self.model_access.create({ - 'model': model.id, - 'group': group.id, - 'perm_delete': True, - }) + model_access_w_group, = self.model_access.create([{ + 'model': model.id, + 'group': group.id, + 'perm_delete': True, + }]) self.test_access.delete([tests.pop()]) @@ -337,7 +337,7 @@ class ModelAccessTestCase(unittest.TestCase): self.test_access.delete([tests.pop()]) # One access allowed for one other group - group = self.group.create({'name': 'Test'}) + group, = self.group.create([{'name': 'Test'}]) self.model_access.write([model_access_w_group], { 'group': group.id, }) @@ -380,10 +380,10 @@ class ModelFieldAccessTestCase(unittest.TestCase): ('name', '=', 'field2'), ]) - test = self.test_access.create({ - 'field1': 'ham', - 'field2': 'spam', - }) + test, = self.test_access.create([{ + 'field1': 'ham', + 'field2': 'spam', + }]) # Without field access self.test_access.read([test.id], ['field1']) @@ -397,11 +397,11 @@ class ModelFieldAccessTestCase(unittest.TestCase): # With field access # One access allowed for any group - field_access_wo_group = self.field_access.create({ - 'field': field1.id, - 'group': False, - 'perm_read': True, - }) + field_access_wo_group, = self.field_access.create([{ + 'field': field1.id, + 'group': False, + 'perm_read': True, + }]) self.test_access.read([test.id], ['field1']) self.test_access.read([test.id], ['field2']) self.test_access.read([test.id]) @@ -426,11 +426,11 @@ class ModelFieldAccessTestCase(unittest.TestCase): # Two access rules with one group allowed group = self.group.search([('users', '=', USER)])[0] - field_access_w_group = self.field_access.create({ - 'field': field1.id, - 'group': group.id, - 'perm_read': True, - }) + field_access_w_group, = self.field_access.create([{ + 'field': field1.id, + 'group': group.id, + 'perm_read': True, + }]) self.test_access.read([test.id], ['field1']) self.test_access.read([test.id], ['field2']) @@ -501,7 +501,7 @@ class ModelFieldAccessTestCase(unittest.TestCase): test = self.test_access(test.id) # One access allowed for one other group - group = self.group.create({'name': 'Test'}) + group, = self.group.create([{'name': 'Test'}]) self.field_access.write([field_access_w_group], { 'group': group.id, }) @@ -528,16 +528,16 @@ class ModelFieldAccessTestCase(unittest.TestCase): # Two access rules on both fields allowed self.field_access.delete([field_access_w_group]) - field_access1 = self.field_access.create({ - 'field': field1.id, - 'group': False, - 'perm_read': True, - }) - field_access2 = self.field_access.create({ - 'field': field2.id, - 'group': False, - 'perm_read': True, - }) + field_access1, = self.field_access.create([{ + 'field': field1.id, + 'group': False, + 'perm_read': True, + }]) + field_access2, = self.field_access.create([{ + 'field': field2.id, + 'group': False, + 'perm_read': True, + }]) self.test_access.read([test.id], ['field1']) self.test_access.read([test.id], ['field2']) @@ -592,10 +592,10 @@ class ModelFieldAccessTestCase(unittest.TestCase): ('name', '=', 'field2'), ]) - test = self.test_access.create({ - 'field1': 'ham', - 'field2': 'spam', - }) + test, = self.test_access.create([{ + 'field1': 'ham', + 'field2': 'spam', + }]) # Without field access self.test_access.write([test], {}) @@ -605,11 +605,11 @@ class ModelFieldAccessTestCase(unittest.TestCase): # With field access # One access allowed for any group - field_access_wo_group = self.field_access.create({ - 'field': field1.id, - 'group': False, - 'perm_write': True, - }) + field_access_wo_group, = self.field_access.create([{ + 'field': field1.id, + 'group': False, + 'perm_write': True, + }]) self.test_access.write([test], {}) self.test_access.write([test], {'field1': 'ham'}) self.test_access.write([test], {'field2': 'spam'}) @@ -634,11 +634,11 @@ class ModelFieldAccessTestCase(unittest.TestCase): # Two access rules with one group allowed group = self.group.search([('users', '=', USER)])[0] - field_access_w_group = self.field_access.create({ - 'field': field1.id, - 'group': group.id, - 'perm_write': True, - }) + field_access_w_group, = self.field_access.create([{ + 'field': field1.id, + 'group': group.id, + 'perm_write': True, + }]) self.test_access.write([test], {}) self.test_access.write([test], {'field1': 'ham'}) @@ -709,7 +709,7 @@ class ModelFieldAccessTestCase(unittest.TestCase): }) # One access allowed for one other group - group = self.group.create({'name': 'Test'}) + group, = self.group.create([{'name': 'Test'}]) self.field_access.write([field_access_w_group], { 'group': group.id, }) @@ -736,16 +736,16 @@ class ModelFieldAccessTestCase(unittest.TestCase): # Two access rules on both fields allowed self.field_access.delete([field_access_w_group]) - field_access1 = self.field_access.create({ - 'field': field1.id, - 'group': False, - 'perm_write': True, - }) - field_access2 = self.field_access.create({ - 'field': field2.id, - 'group': False, - 'perm_write': True, - }) + field_access1, = self.field_access.create([{ + 'field': field1.id, + 'group': False, + 'perm_write': True, + }]) + field_access2, = self.field_access.create([{ + 'field': field2.id, + 'group': False, + 'perm_write': True, + }]) self.test_access.write([test], {}) self.test_access.write([test], {'field1': 'ham'}) diff --git a/trytond/tests/test_exportdata.py b/trytond/tests/test_exportdata.py index e4fae01a70..e88b9df4b9 100644 --- a/trytond/tests/test_exportdata.py +++ b/trytond/tests/test_exportdata.py @@ -35,15 +35,15 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - export1 = self.export_data.create({ - 'boolean': True, - }) + export1, = self.export_data.create([{ + 'boolean': True, + }]) self.assertEqual( self.export_data.export_data([export1], ['boolean']), [[True]]) - export2 = self.export_data.create({ - 'boolean': False, - }) + export2, = self.export_data.create([{ + 'boolean': False, + }]) self.assertEqual( self.export_data.export_data([export2], ['boolean']), [[False]]) @@ -61,15 +61,15 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - export1 = self.export_data.create({ - 'integer': 2, - }) + export1, = self.export_data.create([{ + 'integer': 2, + }]) self.assertEqual( self.export_data.export_data([export1], ['integer']), [[2]]) - export2 = self.export_data.create({ - 'integer': 0, - }) + export2, = self.export_data.create([{ + 'integer': 0, + }]) self.assertEqual( self.export_data.export_data([export2], ['integer']), [[0]]) @@ -85,15 +85,15 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - export1 = self.export_data.create({ - 'float': 1.1, - }) + export1, = self.export_data.create([{ + 'float': 1.1, + }]) self.assertEqual( self.export_data.export_data([export1], ['float']), [[1.1]]) - export2 = self.export_data.create({ - 'float': 0, - }) + export2, = self.export_data.create([{ + 'float': 0, + }]) self.assertEqual( self.export_data.export_data([export2], ['float']), [[0]]) @@ -109,16 +109,16 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - export1 = self.export_data.create({ - 'numeric': Decimal('1.1'), - }) + export1, = self.export_data.create([{ + 'numeric': Decimal('1.1'), + }]) self.assertEqual( self.export_data.export_data([export1], ['numeric']), [[Decimal('1.1')]]) - export2 = self.export_data.create({ - 'numeric': Decimal('0'), - }) + export2, = self.export_data.create([{ + 'numeric': Decimal('0'), + }]) self.assertEqual( self.export_data.export_data([export2], ['numeric']), [[Decimal('0')]]) @@ -135,15 +135,15 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - export1 = self.export_data.create({ - 'char': 'test', - }) + export1, = self.export_data.create([{ + 'char': 'test', + }]) self.assertEqual( self.export_data.export_data([export1], ['char']), [['test']]) - export2 = self.export_data.create({ - 'char': None, - }) + export2, = self.export_data.create([{ + 'char': None, + }]) self.assertEqual( self.export_data.export_data([export2], ['char']), [['']]) @@ -159,15 +159,15 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - export1 = self.export_data.create({ - 'text': 'test', - }) + export1, = self.export_data.create([{ + 'text': 'test', + }]) self.assertEqual( self.export_data.export_data([export1], ['text']), [['test']]) - export2 = self.export_data.create({ - 'text': None, - }) + export2, = self.export_data.create([{ + 'text': None, + }]) self.assertEqual( self.export_data.export_data([export2], ['text']), [['']]) @@ -183,9 +183,9 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - export1 = self.export_data.create({ - 'sha': 'Test', - }) + export1, = self.export_data.create([{ + 'sha': 'Test', + }]) self.assertEqual( self.export_data.export_data([export1], ['sha']), [['640ab2bae07bedc4c163f679a746f7ab7fb5d1fa']]) @@ -198,15 +198,15 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - export1 = self.export_data.create({ - 'date': datetime.date(2010, 1, 1), - }) + export1, = self.export_data.create([{ + 'date': datetime.date(2010, 1, 1), + }]) self.assert_(self.export_data.export_data([export1], ['date']) == [[datetime.date(2010, 1, 1)]]) - export2 = self.export_data.create({ - 'date': None, - }) + export2, = self.export_data.create([{ + 'date': None, + }]) self.assertEqual( self.export_data.export_data([export2], ['date']), [['']]) @@ -222,16 +222,16 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - export1 = self.export_data.create({ - 'datetime': datetime.datetime(2010, 1, 1, 12, 0, 0), - }) + export1, = self.export_data.create([{ + 'datetime': datetime.datetime(2010, 1, 1, 12, 0, 0), + }]) self.assertEqual( self.export_data.export_data([export1], ['datetime']), [[datetime.datetime(2010, 1, 1, 12, 0, 0)]]) - export2 = self.export_data.create({ - 'datetime': None, - }) + export2, = self.export_data.create([{ + 'datetime': None, + }]) self.assertEqual( self.export_data.export_data([export2], ['datetime']), [['']]) @@ -248,16 +248,16 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - export1 = self.export_data.create({ - 'selection': 'select1', - }) + export1, = self.export_data.create([{ + 'selection': 'select1', + }]) self.assertEqual( self.export_data.export_data([export1], ['selection']), [['select1']]) - export2 = self.export_data.create({ - 'selection': None, - }) + export2, = self.export_data.create([{ + 'selection': None, + }]) self.assertEqual( self.export_data.export_data([export2], ['selection']), [['']]) @@ -274,19 +274,19 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - target = self.export_data_target.create({ - 'name': 'Target Test', - }) - export1 = self.export_data.create({ - 'many2one': target.id, - }) + target, = self.export_data_target.create([{ + 'name': 'Target Test', + }]) + export1, = self.export_data.create([{ + 'many2one': target.id, + }]) self.assertEqual( self.export_data.export_data([export1], ['many2one/name']), [['Target Test']]) - export2 = self.export_data.create({ + export2, = self.export_data.create([{ 'many2one': None, - }) + }]) self.assertEqual( self.export_data.export_data([export2], ['many2one/name']), [['']]) @@ -304,19 +304,19 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - target1 = self.export_data_target.create({ - 'name': 'Target 1', - }) - export1 = self.export_data.create({ - 'many2many': [('set', [target1])], - }) + target1, = self.export_data_target.create([{ + 'name': 'Target 1', + }]) + export1, = self.export_data.create([{ + 'many2many': [('set', [target1])], + }]) self.assertEqual( self.export_data.export_data([export1], ['many2many/name']), [['Target 1']]) - target2 = self.export_data_target.create({ - 'name': 'Target 2', - }) + target2, = self.export_data_target.create([{ + 'name': 'Target 2', + }]) self.export_data.write([export1], { 'many2many': [('set', [target1.id, target2.id])], }) @@ -325,9 +325,9 @@ class ExportDataTestCase(unittest.TestCase): 'many2many/name']), [[export1.id, 'Target 1'], ['', 'Target 2']]) - export2 = self.export_data.create({ - 'many2many': None, - }) + export2, = self.export_data.create([{ + 'many2many': None, + }]) self.assertEqual( self.export_data.export_data([export2], ['many2many/name']), [['']]) @@ -345,25 +345,25 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - export1 = self.export_data.create({}) - self.export_data_target.create({ - 'name': 'Target 1', - 'one2many': export1.id, - }) + export1, = self.export_data.create([{}]) + self.export_data_target.create([{ + 'name': 'Target 1', + 'one2many': export1.id, + }]) self.assertEqual( self.export_data.export_data([export1], ['one2many/name']), [['Target 1']]) - self.export_data_target.create({ - 'name': 'Target 2', - 'one2many': export1.id, - }) + self.export_data_target.create([{ + 'name': 'Target 2', + 'one2many': export1.id, + }]) self.assertEqual( self.export_data.export_data([export1], ['id', 'one2many/name']), [[export1.id, 'Target 1'], ['', 'Target 2']]) - export2 = self.export_data.create({}) + export2, = self.export_data.create([{}]) self.assertEqual( self.export_data.export_data([export2], ['one2many/name']), [['']]) @@ -381,17 +381,17 @@ class ExportDataTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - target1 = self.export_data_target.create({}) - export1 = self.export_data.create({ - 'reference': str(target1), - }) + target1, = self.export_data_target.create([{}]) + export1, = self.export_data.create([{ + 'reference': str(target1), + }]) self.assertEqual( self.export_data.export_data([export1], ['reference']), [[str(target1)]]) - export2 = self.export_data.create({ - 'reference': None, - }) + export2, = self.export_data.create([{ + 'reference': None, + }]) self.assertEqual( self.export_data.export_data([export2], ['reference']), [['']]) diff --git a/trytond/tests/test_fields.py b/trytond/tests/test_fields.py index 563466cc87..f807e428d8 100644 --- a/trytond/tests/test_fields.py +++ b/trytond/tests/test_fields.py @@ -108,9 +108,9 @@ class FieldsTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - boolean1 = self.boolean.create({ - 'boolean': True, - }) + boolean1, = self.boolean.create([{ + 'boolean': True, + }]) self.assert_(boolean1) self.assertEqual(boolean1.boolean, True) @@ -144,9 +144,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(booleans, [boolean1]) - boolean2 = self.boolean.create({ - 'boolean': False, - }) + boolean2, = self.boolean.create([{ + 'boolean': False, + }]) self.assert_(boolean2) self.assertEqual(boolean2.boolean, False) @@ -165,14 +165,14 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(booleans, []) - boolean3 = self.boolean.create({}) + boolean3, = self.boolean.create([{}]) self.assert_(boolean3) self.assertEqual(boolean3.boolean, False) # Test search with NULL value - boolean4 = self.boolean.create({ - 'boolean': None, - }) + boolean4, = self.boolean.create([{ + 'boolean': None, + }]) self.assert_(boolean4) booleans = self.boolean.search([ @@ -186,7 +186,7 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(booleans, [boolean1]) - boolean4 = self.boolean_default.create({}) + boolean4, = self.boolean_default.create([{}]) self.assert_(boolean4) self.assert_(boolean4.boolean == True) @@ -208,9 +208,9 @@ class FieldsTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - integer1 = self.integer.create({ - 'integer': 1, - }) + integer1, = self.integer.create([{ + 'integer': 1, + }]) self.assert_(integer1) self.assertEqual(integer1.integer, 1) @@ -324,9 +324,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(integers, [integer1]) - integer2 = self.integer.create({ - 'integer': 0, - }) + integer2, = self.integer.create([{ + 'integer': 0, + }]) self.assert_(integer2) self.assertEqual(integer2.integer, 0) @@ -345,11 +345,11 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(integers, []) - integer3 = self.integer.create({}) + integer3, = self.integer.create([{}]) self.assert_(integer3) self.assertEqual(integer3.integer, None) - integer4 = self.integer_default.create({}) + integer4, = self.integer_default.create([{}]) self.assert_(integer4) self.assertEqual(integer4.integer, 5) @@ -363,9 +363,9 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(integer2.integer, 1) - self.assertRaises(Exception, self.integer.create, { - 'integer': 'test', - }) + self.assertRaises(Exception, self.integer.create, [{ + 'integer': 'test', + }]) self.assertRaises(Exception, self.integer.write, [integer1], { 'integer': 'test', @@ -373,12 +373,12 @@ class FieldsTestCase(unittest.TestCase): # We should catch UserError but mysql does not raise an # IntegrityError but an OperationalError - self.assertRaises(Exception, self.integer_required.create, {}) + self.assertRaises(Exception, self.integer_required.create, [{}]) transaction.cursor.rollback() - integer5 = self.integer_required.create({ - 'integer': 0, - }) + integer5, = self.integer_required.create([{ + 'integer': 0, + }]) self.assert_(integer5) self.assertEqual(integer5.integer, 0) @@ -390,9 +390,9 @@ class FieldsTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - float1 = self.float.create({ - 'float': 1.1, - }) + float1, = self.float.create([{ + 'float': 1.1, + }]) self.assert_(float1) self.assertEqual(float1.float, 1.1) @@ -506,9 +506,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(floats, [float1]) - float2 = self.float.create({ - 'float': 0, - }) + float2, = self.float.create([{ + 'float': 0, + }]) self.assert_(float2) self.assertEqual(float2.float, 0) @@ -527,11 +527,11 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(floats, []) - float3 = self.float.create({}) + float3, = self.float.create([{}]) self.assert_(float3) self.assertEqual(float3.float, None) - float4 = self.float_default.create({}) + float4, = self.float_default.create([{}]) self.assert_(float4) self.assertEqual(float4.float, 5.5) @@ -545,32 +545,32 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(float2.float, 1.1) - self.assertRaises(Exception, self.float.create, { - 'float': 'test', - }) + self.assertRaises(Exception, self.float.create, [{ + 'float': 'test', + }]) self.assertRaises(Exception, self.float.write, [float1], { 'float': 'test', }) - self.assertRaises(Exception, self.float_required.create, {}) + self.assertRaises(Exception, self.float_required.create, [{}]) transaction.cursor.rollback() - float5 = self.float_required.create({ - 'float': 0.0, - }) + float5, = self.float_required.create([{ + 'float': 0.0, + }]) self.assertEqual(float5.float, 0.0) - float6 = self.float_digits.create({ - 'digits': 1, - 'float': 1.1, - }) + float6, = self.float_digits.create([{ + 'digits': 1, + 'float': 1.1, + }]) self.assert_(float6) - self.assertRaises(Exception, self.float_digits.create, { - 'digits': 1, - 'float': 1.11, - }) + self.assertRaises(Exception, self.float_digits.create, [{ + 'digits': 1, + 'float': 1.11, + }]) self.assertRaises(Exception, self.float_digits.write, [float6], { @@ -582,9 +582,9 @@ class FieldsTestCase(unittest.TestCase): 'digits': 0, }) - float7 = self.float.create({ - 'float': 0.123456789012345, - }) + float7, = self.float.create([{ + 'float': 0.123456789012345, + }]) self.assertEqual(float7.float, 0.123456789012345) transaction.cursor.rollback() @@ -595,9 +595,9 @@ class FieldsTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - numeric1 = self.numeric.create({ - 'numeric': Decimal('1.1'), - }) + numeric1, = self.numeric.create([{ + 'numeric': Decimal('1.1'), + }]) self.assert_(numeric1) self.assertEqual(numeric1.numeric, Decimal('1.1')) @@ -711,9 +711,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(numerics, [numeric1]) - numeric2 = self.numeric.create({ - 'numeric': Decimal('0'), - }) + numeric2, = self.numeric.create([{ + 'numeric': Decimal('0'), + }]) self.assert_(numeric2) self.assertEqual(numeric2.numeric, Decimal('0')) @@ -732,11 +732,11 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(numerics, []) - numeric3 = self.numeric.create({}) + numeric3, = self.numeric.create([{}]) self.assert_(numeric3) self.assertEqual(numeric3.numeric, None) - numeric4 = self.numeric_default.create({}) + numeric4, = self.numeric_default.create([{}]) self.assert_(numeric4) self.assertEqual(numeric4.numeric, Decimal('5.5')) @@ -750,32 +750,32 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(numeric2.numeric, Decimal('1.1')) - self.assertRaises(Exception, self.numeric.create, { - 'numeric': 'test', - }) + self.assertRaises(Exception, self.numeric.create, [{ + 'numeric': 'test', + }]) self.assertRaises(Exception, self.numeric.write, [numeric1], { 'numeric': 'test', }) - self.assertRaises(Exception, self.numeric_required.create, {}) + self.assertRaises(Exception, self.numeric_required.create, [{}]) transaction.cursor.rollback() - numeric5 = self.numeric_required.create({ + numeric5, = self.numeric_required.create([{ 'numeric': Decimal(0), - }) + }]) self.assertEqual(numeric5.numeric, 0) - numeric6 = self.numeric_digits.create({ - 'digits': 1, - 'numeric': Decimal('1.1'), - }) + numeric6, = self.numeric_digits.create([{ + 'digits': 1, + 'numeric': Decimal('1.1'), + }]) self.assert_(numeric6) - self.assertRaises(Exception, self.numeric_digits.create, { - 'digits': 1, - 'numeric': Decimal('1.11'), - }) + self.assertRaises(Exception, self.numeric_digits.create, [{ + 'digits': 1, + 'numeric': Decimal('1.11'), + }]) self.assertRaises(Exception, self.numeric_digits.write, [numeric6], { @@ -792,9 +792,9 @@ class FieldsTestCase(unittest.TestCase): 'digits': 0, }) - numeric7 = self.numeric.create({ - 'numeric': Decimal('0.1234567890123456789'), - }) + numeric7, = self.numeric.create([{ + 'numeric': Decimal('0.1234567890123456789'), + }]) self.assertEqual(numeric7.numeric, Decimal('0.1234567890123456789')) @@ -807,9 +807,9 @@ class FieldsTestCase(unittest.TestCase): with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: for char in (self.char_translate, self.char): - char1 = char.create({ - 'char': 'Test', - }) + char1, = char.create([{ + 'char': 'Test', + }]) self.assert_(char1) self.assertEqual(char1.char, 'Test') @@ -963,9 +963,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(chars, [char1]) - char2 = char.create({ - 'char': None, - }) + char2, = char.create([{ + 'char': None, + }]) self.assert_(char2) self.assertEqual(char2.char, None) @@ -984,11 +984,11 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(chars, []) - char3 = self.char.create({}) + char3, = self.char.create([{}]) self.assert_(char3) self.assertEqual(char3.char, None) - char4 = self.char_default.create({}) + char4, = self.char_default.create([{}]) self.assert_(char4) self.assertEqual(char4.char, 'Test') @@ -1002,36 +1002,36 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(char2.char, 'Test') - self.assertRaises(Exception, self.char_required.create, {}) + self.assertRaises(Exception, self.char_required.create, [{}]) transaction.cursor.rollback() - self.assertRaises(Exception, self.char_required.create, { + self.assertRaises(Exception, self.char_required.create, [{ 'char': '', - }) + }]) transaction.cursor.rollback() - char5 = self.char_required.create({ - 'char': 'Test', - }) + char5, = self.char_required.create([{ + 'char': 'Test', + }]) self.assert_(char5) - char6 = self.char_size.create({ - 'char': 'Test', - }) + char6, = self.char_size.create([{ + 'char': 'Test', + }]) self.assert_(char6) - self.assertRaises(Exception, self.char_size.create, { + self.assertRaises(Exception, self.char_size.create, [{ 'char': 'foobar', - }) + }]) self.assertRaises(Exception, self.char_size.write, [char6], { 'char': 'foobar', }) transaction.cursor.rollback() - char7 = self.char.create({ - 'char': u'é', - }) + char7, = self.char.create([{ + 'char': u'é', + }]) self.assert_(char7) self.assertEqual(char7.char, u'é') @@ -1059,9 +1059,9 @@ class FieldsTestCase(unittest.TestCase): with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: for text in (self.text_translate, self.text): - text1 = text.create({ - 'text': 'Test', - }) + text1, = text.create([{ + 'text': 'Test', + }]) self.assert_(text1) self.assertEqual(text1.text, 'Test') @@ -1215,9 +1215,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(texts, [text1]) - text2 = text.create({ - 'text': None, - }) + text2, = text.create([{ + 'text': None, + }]) self.assert_(text2) self.assertEqual(text2.text, None) @@ -1236,11 +1236,11 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(texts, []) - text3 = self.text.create({}) + text3, = self.text.create([{}]) self.assert_(text3) self.assertEqual(text3.text, None) - text4 = self.text_default.create({}) + text4, = self.text_default.create([{}]) self.assert_(text4) self.assertEqual(text4.text, 'Test') @@ -1254,35 +1254,35 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(text2.text, 'Test') - self.assertRaises(Exception, self.text_required.create, {}) + self.assertRaises(Exception, self.text_required.create, [{}]) transaction.cursor.rollback() - text5 = self.text_required.create({ - 'text': 'Test', - }) + text5, = self.text_required.create([{ + 'text': 'Test', + }]) self.assert_(text5) - text6 = self.text_size.create({ - 'text': 'Test', - }) + text6, = self.text_size.create([{ + 'text': 'Test', + }]) self.assert_(text6) - self.assertRaises(Exception, self.text_size.create, { - 'text': 'foobar', - }) + self.assertRaises(Exception, self.text_size.create, [{ + 'text': 'foobar', + }]) self.assertRaises(Exception, self.text_size.write, [text6], { 'text': 'foobar', }) - text7 = self.text.create({ - 'text': 'Foo\nBar', - }) + text7, = self.text.create([{ + 'text': 'Foo\nBar', + }]) self.assert_(text7) - text8 = self.text.create({ - 'text': u'é', - }) + text8, = self.text.create([{ + 'text': u'é', + }]) self.assert_(text8) self.assertEqual(text8.text, u'é') @@ -1309,9 +1309,9 @@ class FieldsTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - sha1 = self.sha.create({ - 'sha': 'Test', - }) + sha1, = self.sha.create([{ + 'sha': 'Test', + }]) self.assert_(sha1) self.assertEqual(sha1.sha, '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa') @@ -1421,9 +1421,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(sha, [sha1]) - sha2 = self.sha.create({ - 'sha': None, - }) + sha2, = self.sha.create([{ + 'sha': None, + }]) self.assert_(sha2) self.assertEqual(sha2.sha, None) @@ -1442,11 +1442,11 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(sha, []) - sha3 = self.sha.create({}) + sha3, = self.sha.create([{}]) self.assert_(sha3) self.assertEqual(sha3.sha, None) - sha4 = self.sha_default.create({}) + sha4, = self.sha_default.create([{}]) self.assert_(sha4) self.assertEqual(sha4.sha, 'ba79baeb9f10896a46ae74715271b7f586e74640') @@ -1462,17 +1462,17 @@ class FieldsTestCase(unittest.TestCase): self.assertEqual(sha2.sha, '640ab2bae07bedc4c163f679a746f7ab7fb5d1fa') - self.assertRaises(Exception, self.sha_required.create, {}) + self.assertRaises(Exception, self.sha_required.create, [{}]) transaction.cursor.rollback() - sha5 = self.sha_required.create({ - 'sha': 'Test', - }) + sha5, = self.sha_required.create([{ + 'sha': 'Test', + }]) self.assert_(sha5) - sha6 = self.sha.create({ - 'sha': u'é', - }) + sha6, = self.sha.create([{ + 'sha': u'é', + }]) self.assert_(sha6) self.assertEqual(sha6.sha, u'bf15be717ac1b080b4f1c456692825891ff5073d') @@ -1506,9 +1506,9 @@ class FieldsTestCase(unittest.TestCase): yesterday = today - datetime.timedelta(1) default_date = datetime.date(2000, 1, 1) - date1 = self.date.create({ - 'date': today, - }) + date1, = self.date.create([{ + 'date': today, + }]) self.assert_(date1) self.assertEqual(date1.date, today) @@ -1642,9 +1642,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(dates, [date1]) - date2 = self.date.create({ - 'date': yesterday, - }) + date2, = self.date.create([{ + 'date': yesterday, + }]) self.assert_(date2) self.assertEqual(date2.date, yesterday) @@ -1663,11 +1663,11 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(dates, []) - date3 = self.date.create({}) + date3, = self.date.create([{}]) self.assert_(date3) self.assertEqual(date3.date, None) - date4 = self.date_default.create({}) + date4, = self.date_default.create([{}]) self.assert_(date4) self.assertEqual(date4.date, default_date) @@ -1681,60 +1681,60 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(date2.date, today) - self.assertRaises(Exception, self.date.create, { - 'date': 'test', - }) + self.assertRaises(Exception, self.date.create, [{ + 'date': 'test', + }]) self.assertRaises(Exception, self.date.write, [date1], { 'date': 'test', }) - self.assertRaises(Exception, self.date.create, { - 'date': 1, - }) + self.assertRaises(Exception, self.date.create, [{ + 'date': 1, + }]) self.assertRaises(Exception, self.date.write, [date1], { 'date': 1, }) - self.assertRaises(Exception, self.date.create, { - 'date': datetime.datetime.now(), - }) + self.assertRaises(Exception, self.date.create, [{ + 'date': datetime.datetime.now(), + }]) self.assertRaises(Exception, self.date.write, [date1], { 'date': datetime.datetime.now(), }) - self.assertRaises(Exception, self.date.create, { - 'date': '2009-13-01', - }) + self.assertRaises(Exception, self.date.create, [{ + 'date': '2009-13-01', + }]) self.assertRaises(Exception, self.date.write, [date1], { 'date': '2009-02-29', }) - date5 = self.date.create({ - 'date': '2009-01-01', - }) + date5, = self.date.create([{ + 'date': '2009-01-01', + }]) self.assert_(date5) self.assertEqual(date5.date, datetime.date(2009, 1, 1)) - self.assertRaises(Exception, self.date_required.create, {}) + self.assertRaises(Exception, self.date_required.create, [{}]) transaction.cursor.rollback() - date6 = self.date_required.create({ - 'date': today, - }) + date6, = self.date_required.create([{ + 'date': today, + }]) self.assert_(date6) - date7 = self.date.create({ - 'date': None, - }) + date7, = self.date.create([{ + 'date': None, + }]) self.assert_(date7) - date8 = self.date.create({ - 'date': None, - }) + date8, = self.date.create([{ + 'date': None, + }]) self.assert_(date8) transaction.cursor.rollback() @@ -1750,9 +1750,9 @@ class FieldsTestCase(unittest.TestCase): yesterday = today - datetime.timedelta(1) default_datetime = datetime.datetime(2000, 1, 1, 12, 0, 0) - datetime1 = self.datetime.create({ - 'datetime': today, - }) + datetime1, = self.datetime.create([{ + 'datetime': today, + }]) self.assert_(datetime1) self.assertEqual(datetime1.datetime, today) @@ -1886,9 +1886,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(datetimes, [datetime1]) - datetime2 = self.datetime.create({ - 'datetime': yesterday, - }) + datetime2, = self.datetime.create([{ + 'datetime': yesterday, + }]) self.assert_(datetime2) self.assertEqual(datetime2.datetime, yesterday) @@ -1907,11 +1907,11 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(datetimes, []) - datetime3 = self.datetime.create({}) + datetime3, = self.datetime.create([{}]) self.assert_(datetime3) self.assertEqual(datetime3.datetime, None) - datetime4 = self.datetime_default.create({}) + datetime4, = self.datetime_default.create([{}]) self.assert_(datetime4) self.assertEqual(datetime4.datetime, default_datetime) @@ -1925,36 +1925,36 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(datetime2.datetime, today) - self.assertRaises(Exception, self.datetime.create, { - 'datetime': 'test', - }) + self.assertRaises(Exception, self.datetime.create, [{ + 'datetime': 'test', + }]) self.assertRaises(Exception, self.datetime.write, [datetime1], { 'datetime': 'test', }) - self.assertRaises(Exception, self.datetime.create, { - 'datetime': 1, - }) + self.assertRaises(Exception, self.datetime.create, [{ + 'datetime': 1, + }]) self.assertRaises(Exception, self.datetime.write, [datetime1], { 'datetime': 1, }) - self.assertRaises(Exception, self.datetime.create, { - 'datetime': datetime.date.today(), - }) + self.assertRaises(Exception, self.datetime.create, [{ + 'datetime': datetime.date.today(), + }]) self.assertRaises(Exception, self.datetime.write, [datetime1], { 'datetime': datetime.date.today(), }) - self.assertRaises(Exception, self.datetime.create, { - 'datetime': '2009-13-01 12:30:00', - }) + self.assertRaises(Exception, self.datetime.create, [{ + 'datetime': '2009-13-01 12:30:00', + }]) self.assertRaises(Exception, self.datetime.write, [datetime1], { @@ -1966,44 +1966,44 @@ class FieldsTestCase(unittest.TestCase): 'datetime': '2009-01-01 25:00:00', }) - datetime5 = self.datetime.create({ + datetime5, = self.datetime.create([{ 'datetime': '2009-01-01 12:00:00', - }) + }]) self.assert_(datetime5) self.assertEqual(datetime5.datetime, datetime.datetime(2009, 1, 1, 12, 0, 0)) - self.assertRaises(Exception, self.datetime_required.create, {}) + self.assertRaises(Exception, self.datetime_required.create, [{}]) transaction.cursor.rollback() - datetime6 = self.datetime_required.create({ - 'datetime': today, - }) + datetime6, = self.datetime_required.create([{ + 'datetime': today, + }]) self.assert_(datetime6) - datetime7 = self.datetime.create({ - 'datetime': None, - }) + datetime7, = self.datetime.create([{ + 'datetime': None, + }]) self.assert_(datetime7) - datetime8 = self.datetime.create({ - 'datetime': None, - }) + datetime8, = self.datetime.create([{ + 'datetime': None, + }]) self.assert_(datetime8) - datetime9 = self.datetime.create({ - 'datetime': today.replace(microsecond=1), - }) + datetime9, = self.datetime.create([{ + 'datetime': today.replace(microsecond=1), + }]) self.assert_(datetime9) self.assertEqual(datetime9.datetime, today) # Test format - self.assert_(self.datetime_format.create({ - 'datetime': datetime.datetime(2009, 1, 1, 12, 30), - })) - self.assertRaises(Exception, self.datetime_format.create, { - 'datetime': datetime.datetime(2009, 1, 1, 12, 30, 25), - }) + self.assert_(self.datetime_format.create([{ + 'datetime': datetime.datetime(2009, 1, 1, 12, 30), + }])) + self.assertRaises(Exception, self.datetime_format.create, [{ + 'datetime': datetime.datetime(2009, 1, 1, 12, 30, 25), + }]) transaction.cursor.rollback() @@ -2018,9 +2018,9 @@ class FieldsTestCase(unittest.TestCase): night = datetime.time(20, 00) default_time = datetime.time(16, 30) - time1 = self.time.create({ - 'time': evening, - }) + time1, = self.time.create([{ + 'time': evening, + }]) self.assert_(time1) self.assertEqual(time1.time, evening) @@ -2154,9 +2154,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(times, [time1]) - time2 = self.time.create({ - 'time': pre_evening, - }) + time2, = self.time.create([{ + 'time': pre_evening, + }]) self.assert_(time2) self.assertEqual(time2.time, pre_evening) @@ -2175,11 +2175,11 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(times, []) - time3 = self.time.create({}) + time3, = self.time.create([{}]) self.assert_(time3) self.assertEqual(time3.time, None) - time4 = self.time_default.create({}) + time4, = self.time_default.create([{}]) self.assert_(time4) self.assertEqual(time4.time, default_time) @@ -2193,18 +2193,18 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(time2.time, evening) - self.assertRaises(Exception, self.time.create, { - 'time': 'test', - }) + self.assertRaises(Exception, self.time.create, [{ + 'time': 'test', + }]) self.assertRaises(Exception, self.time.write, [time1], { 'time': 'test', }) - self.assertRaises(Exception, self.time.create, { + self.assertRaises(Exception, self.time.create, [{ 'time': 1, - }) + }]) self.assertRaises(Exception, self.time.write, [time1], { @@ -2216,43 +2216,43 @@ class FieldsTestCase(unittest.TestCase): 'time': '25:00:00', }) - time5 = self.time.create({ - 'time': '12:00:00', - }) + time5, = self.time.create([{ + 'time': '12:00:00', + }]) self.assert_(time5) self.assertEqual(time5.time, datetime.time(12, 0)) - self.assertRaises(Exception, self.time_required.create, {}) + self.assertRaises(Exception, self.time_required.create, [{}]) transaction.cursor.rollback() - time6 = self.time_required.create({ - 'time': evening, - }) + time6, = self.time_required.create([{ + 'time': evening, + }]) self.assert_(time6) - time7 = self.time.create({ - 'time': None, - }) + time7, = self.time.create([{ + 'time': None, + }]) self.assert_(time7) - time8 = self.time.create({ - 'time': False, - }) + time8, = self.time.create([{ + 'time': False, + }]) self.assert_(time8) - time9 = self.time.create({ - 'time': evening.replace(microsecond=1), - }) + time9, = self.time.create([{ + 'time': evening.replace(microsecond=1), + }]) self.assert_(time9) self.assertEqual(time9.time, evening) # Test format - self.assert_(self.time_format.create({ + self.assert_(self.time_format.create([{ 'time': datetime.time(12, 30), - })) - self.assertRaises(Exception, self.time_format.create, { + }])) + self.assertRaises(Exception, self.time_format.create, [{ 'time': datetime.time(12, 30, 25), - }) + }]) transaction.cursor.rollback() @@ -2262,13 +2262,13 @@ class FieldsTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - target1 = self.one2one_target.create({ - 'name': 'target1', - }) - one2one1 = self.one2one.create({ - 'name': 'origin1', - 'one2one': target1.id, - }) + target1, = self.one2one_target.create([{ + 'name': 'target1', + }]) + one2one1, = self.one2one.create([{ + 'name': 'origin1', + 'one2one': target1.id, + }]) self.assert_(one2one1) self.assertEqual(one2one1.one2one, target1) @@ -2315,9 +2315,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(one2ones, []) - one2one2 = self.one2one.create({ - 'name': 'origin2', - }) + one2one2, = self.one2one.create([{ + 'name': 'origin2', + }]) self.assert_(one2one2) self.assertEqual(one2one2.one2one, None) @@ -2326,9 +2326,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(one2ones, [one2one2]) - target2 = self.one2one_target.create({ - 'name': 'target2', - }) + target2, = self.one2one_target.create([{ + 'name': 'target2', + }]) self.one2one.write([one2one2], { 'one2one': target2.id, }) @@ -2339,10 +2339,10 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(one2one2.one2one, None) - self.assertRaises(Exception, self.one2one.create, { - 'name': 'one2one3', - 'one2one': target1.id, - }) + self.assertRaises(Exception, self.one2one.create, [{ + 'name': 'one2one3', + 'one2one': target1.id, + }]) transaction.cursor.rollback() self.assertRaises(Exception, self.one2one.write, [one2one2], { @@ -2350,19 +2350,19 @@ class FieldsTestCase(unittest.TestCase): }) transaction.cursor.rollback() - self.assertRaises(Exception, self.one2one_required.create, { - 'name': 'one2one3', - }) + self.assertRaises(Exception, self.one2one_required.create, [{ + 'name': 'one2one3', + }]) transaction.cursor.rollback() - target3 = self.one2one_target.create({ - 'name': 'target3', - }) + target3, = self.one2one_target.create([{ + 'name': 'target3', + }]) - one2one3 = self.one2one_required.create({ - 'name': 'one2one3', - 'one2one': target3.id, - }) + one2one3, = self.one2one_required.create([{ + 'name': 'one2one3', + 'one2one': target3.id, + }]) self.assert_(one2one3) transaction.cursor.rollback() @@ -2377,14 +2377,14 @@ class FieldsTestCase(unittest.TestCase): (self.one2many, self.one2many_target), (self.one2many_reference, self.one2many_reference_target), ): - one2many1 = one2many.create({ - 'name': 'origin1', - 'targets': [ - ('create', { - 'name': 'target1', - }), - ], - }) + one2many1, = one2many.create([{ + 'name': 'origin1', + 'targets': [ + ('create', [{ + 'name': 'target1', + }]), + ], + }]) self.assert_(one2many1) self.assertEqual(len(one2many1.targets), 1) @@ -2436,9 +2436,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(one2manys, []) - one2many2 = one2many.create({ - 'name': 'origin2', - }) + one2many2, = one2many.create([{ + 'name': 'origin2', + }]) self.assert_(one2many2) self.assertEqual(one2many2.targets, ()) @@ -2457,9 +2457,9 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(target1.name, 'target1bis') - target2 = one2many_target.create({ - 'name': 'target2', - }) + target2, = one2many_target.create([{ + 'name': 'target2', + }]) one2many.write([one2many1], { 'targets': [ ('add', [target2.id]), @@ -2522,35 +2522,35 @@ class FieldsTestCase(unittest.TestCase): transaction.cursor.rollback() - self.assertRaises(Exception, self.one2many_required.create, { - 'name': 'origin3', - }) + self.assertRaises(Exception, self.one2many_required.create, [{ + 'name': 'origin3', + }]) transaction.cursor.rollback() - origin3_id = self.one2many_required.create({ - 'name': 'origin3', - 'targets': [ - ('create', { - 'name': 'target3', - }), - ], - }) + origin3_id, = self.one2many_required.create([{ + 'name': 'origin3', + 'targets': [ + ('create', [{ + 'name': 'target3', + }]), + ], + }]) self.assert_(origin3_id) - self.one2many_size.create({ - 'targets': [('create', {})] * 3, - }) - self.assertRaises(Exception, self.one2many_size.create, { - 'targets': [('create', {})] * 4, - }) - self.one2many_size_pyson.create({ - 'limit': 4, - 'targets': [('create', {})] * 4, - }) - self.assertRaises(Exception, self.one2many_size_pyson.create, { - 'limit': 2, - 'targets': [('create', {})] * 4, - }) + self.one2many_size.create([{ + 'targets': [('create', [{}])] * 3, + }]) + self.assertRaises(Exception, self.one2many_size.create, [{ + 'targets': [('create', [{}])] * 4, + }]) + self.one2many_size_pyson.create([{ + 'limit': 4, + 'targets': [('create', [{}])] * 4, + }]) + self.assertRaises(Exception, self.one2many_size_pyson.create, [{ + 'limit': 2, + 'targets': [('create', [{}])] * 4, + }]) transaction.cursor.rollback() @@ -2565,14 +2565,14 @@ class FieldsTestCase(unittest.TestCase): (self.many2many_reference, self.many2many_reference_target), ): - many2many1 = many2many.create({ - 'name': 'origin1', - 'targets': [ - ('create', { - 'name': 'target1', - }), - ], - }) + many2many1, = many2many.create([{ + 'name': 'origin1', + 'targets': [ + ('create', [{ + 'name': 'target1', + }]), + ], + }]) self.assert_(many2many1) self.assertEqual(len(many2many1.targets), 1) @@ -2618,9 +2618,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(many2manys, []) - many2many2 = many2many.create({ - 'name': 'origin2', - }) + many2many2, = many2many.create([{ + 'name': 'origin2', + }]) self.assert_(many2many2) self.assertEqual(many2many2.targets, ()) @@ -2639,9 +2639,9 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(target1.name, 'target1bis') - target2 = many2many_target.create({ - 'name': 'target2', - }) + target2, = many2many_target.create([{ + 'name': 'target2', + }]) many2many.write([many2many1], { 'targets': [ ('add', [target2.id]), @@ -2704,32 +2704,31 @@ class FieldsTestCase(unittest.TestCase): transaction.cursor.rollback() - self.assertRaises(Exception, self.many2many_required.create, { - 'name': 'origin3', - }) + self.assertRaises(Exception, self.many2many_required.create, [{ + 'name': 'origin3', + }]) transaction.cursor.rollback() - origin3_id = self.many2many_required.create({ - 'name': 'origin3', - 'targets': [ - ('create', { - 'name': 'target3', - }), - ], - }) + origin3_id, = self.many2many_required.create([{ + 'name': 'origin3', + 'targets': [ + ('create', [{ + 'name': 'target3', + }]), + ], + }]) self.assert_(origin3_id) - size_targets = [ - self.many2many_size_target.create({ + size_targets = self.many2many_size_target.create([{ 'name': str(i), - }) for i in range(6)] + } for i in range(6)]) - self.many2many_size.create({ - 'targets': [('set', size_targets[:5])], - }) - self.assertRaises(Exception, self.many2many_size.create, { - 'targets': [('set', size_targets)], - }) + self.many2many_size.create([{ + 'targets': [('set', size_targets[:5])], + }]) + self.assertRaises(Exception, self.many2many_size.create, [{ + 'targets': [('set', size_targets)], + }]) transaction.cursor.rollback() @@ -2739,13 +2738,13 @@ class FieldsTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - target1 = self.reference_target.create({ - 'name': 'target1', - }) - reference1 = self.reference.create({ - 'name': 'reference1', - 'reference': str(target1), - }) + target1, = self.reference_target.create([{ + 'name': 'target1', + }]) + reference1, = self.reference.create([{ + 'name': 'reference1', + 'reference': str(target1), + }]) self.assert_(reference1) self.assertEqual(reference1.reference, target1) @@ -2807,9 +2806,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(references, [reference1]) - reference2 = self.reference.create({ - 'name': 'reference2', - }) + reference2, = self.reference.create([{ + 'name': 'reference2', + }]) self.assert_(reference2) self.assertEqual(reference2.reference, None) @@ -2819,9 +2818,9 @@ class FieldsTestCase(unittest.TestCase): ]) self.assertEqual(references, [reference2]) - target2 = self.reference_target.create({ - 'name': 'target2', - }) + target2, = self.reference_target.create([{ + 'name': 'target2', + }]) self.reference.write([reference2], { 'reference': str(target2), @@ -2838,25 +2837,25 @@ class FieldsTestCase(unittest.TestCase): }) self.assertEqual(reference2.reference, target2) - reference3 = self.reference.create({ - 'name': 'reference3', - 'reference': ('test.reference.target', target1.id), - }) + reference3, = self.reference.create([{ + 'name': 'reference3', + 'reference': ('test.reference.target', target1.id), + }]) self.assert_(reference3) - self.assertRaises(Exception, self.reference_required.create, { - 'name': 'reference4', - }) + self.assertRaises(Exception, self.reference_required.create, [{ + 'name': 'reference4', + }]) transaction.cursor.rollback() - target4 = self.reference_target.create({ - 'name': 'target4_id', - }) + target4, = self.reference_target.create([{ + 'name': 'target4_id', + }]) - reference4 = self.reference_required.create({ - 'name': 'reference4', - 'reference': str(target4), - }) + reference4, = self.reference_required.create([{ + 'name': 'reference4', + 'reference': str(target4), + }]) self.assert_(reference4) transaction.cursor.rollback() @@ -2869,15 +2868,15 @@ class FieldsTestCase(unittest.TestCase): context=CONTEXT) as transaction: # Test Char - prop_a = self.property_.create({'char': 'Test'}) + prop_a, = self.property_.create([{'char': 'Test'}]) self.assert_(prop_a) self.assertEqual(prop_a.char, 'Test') - prop_b = self.property_.create({}) + prop_b, = self.property_.create([{}]) self.assert_(prop_b) self.assertEqual(prop_b.char, None) - prop_c = self.property_.create({'char': 'FooBar'}) + prop_c, = self.property_.create([{'char': 'FooBar'}]) self.assert_(prop_c) self.assertEqual(prop_c.char, 'FooBar') @@ -2924,12 +2923,12 @@ class FieldsTestCase(unittest.TestCase): ('model.model', '=', 'test.property'), ('name', '=', 'char'), ], limit=1) - self.ir_property.create({ - 'field': property_field.id, - 'value': ',DEFAULT_VALUE', - }) + self.ir_property.create([{ + 'field': property_field.id, + 'value': ',DEFAULT_VALUE', + }]) - prop_d = self.property_.create({}) + prop_d, = self.property_.create([{}]) self.assert_(prop_d) self.assertEqual(prop_d.char, 'DEFAULT_VALUE') @@ -2945,21 +2944,21 @@ class FieldsTestCase(unittest.TestCase): transaction.cursor.rollback() # Test Many2One - char_a = self.char.create({'char': 'Test'}) + char_a, = self.char.create([{'char': 'Test'}]) self.assert_(char_a) - char_b = self.char.create({'char': 'FooBar'}) + char_b, = self.char.create([{'char': 'FooBar'}]) self.assert_(char_b) - prop_a = self.property_.create({'many2one': char_a.id}) + prop_a, = self.property_.create([{'many2one': char_a.id}]) self.assert_(prop_a) self.assertEqual(prop_a.many2one, char_a) - prop_b = self.property_.create({'many2one': char_b.id}) + prop_b, = self.property_.create([{'many2one': char_b.id}]) self.assert_(prop_b) self.assertEqual(prop_b.many2one, char_b) - prop_c = self.property_.create({}) + prop_c, = self.property_.create([{}]) self.assert_(prop_c) self.assertEqual(prop_c.many2one, None) @@ -2988,15 +2987,15 @@ class FieldsTestCase(unittest.TestCase): transaction.cursor.rollback() # Test Numeric - prop_a = self.property_.create({'numeric': Decimal('1.1')}) + prop_a, = self.property_.create([{'numeric': Decimal('1.1')}]) self.assert_(prop_a) self.assertEqual(prop_a.numeric, Decimal('1.1')) - prop_b = self.property_.create({'numeric': Decimal('2.6')}) + prop_b, = self.property_.create([{'numeric': Decimal('2.6')}]) self.assert_(prop_b) self.assertEqual(prop_b.numeric, Decimal('2.6')) - prop_c = self.property_.create({}) + prop_c, = self.property_.create([{}]) self.assert_(prop_c) self.assertEqual(prop_c.numeric, None) @@ -3054,12 +3053,12 @@ class FieldsTestCase(unittest.TestCase): ('model.model', '=', 'test.property'), ('name', '=', 'numeric'), ], limit=1) - self.ir_property.create({ - 'field': property_field.id, - 'value': ',3.7', - }) + self.ir_property.create([{ + 'field': property_field.id, + 'value': ',3.7', + }]) - prop_d = self.property_.create({}) + prop_d, = self.property_.create([{}]) self.assert_(prop_d) self.assertEqual(prop_d.numeric, Decimal('3.7')) @@ -3072,15 +3071,15 @@ class FieldsTestCase(unittest.TestCase): transaction.cursor.rollback() # Test Selection - prop_a = self.property_.create({'selection': 'option_a'}) + prop_a, = self.property_.create([{'selection': 'option_a'}]) self.assert_(prop_a) self.assertEqual(prop_a.selection, 'option_a') - prop_b = self.property_.create({'selection': 'option_b'}) + prop_b, = self.property_.create([{'selection': 'option_b'}]) self.assert_(prop_b) self.assertEqual(prop_b.selection, 'option_b') - prop_c = self.property_.create({}) + prop_c, = self.property_.create([{}]) self.assert_(prop_c) self.assertEqual(prop_c.selection, None) @@ -3113,12 +3112,12 @@ class FieldsTestCase(unittest.TestCase): ('model.model', '=', 'test.property'), ('name', '=', 'selection'), ], limit=1) - self.ir_property.create({ - 'field': property_field.id, - 'value': ',option_a', - }) + self.ir_property.create([{ + 'field': property_field.id, + 'value': ',option_a', + }]) - prop_d = self.property_.create({}) + prop_d, = self.property_.create([{}]) self.assert_(prop_d) self.assertEqual(prop_d.selection, 'option_a') diff --git a/trytond/tests/test_model_inherits.py b/trytond/tests/test_model_inherits.py index 3f9a46dd82..1f7282c3f8 100644 --- a/trytond/tests/test_model_inherits.py +++ b/trytond/tests/test_model_inherits.py @@ -22,26 +22,26 @@ class ModelInheritsTestCase(unittest.TestCase): self.overridden = POOL.get('test.overriddeninheritedfieldmodel') def create_data(self): - parent_id = self.parent.create({'name': 'parent'}) - sub_id = self.sub.create({ - 'name': 'sub', - 'subfield': 'level1', - }) - subsub_id = self.subsub.create({ - 'name': 'subsub', - 'subfield': 'level2', - 'subsubfield': 'ssfcontent', - }) - subsubsub_id = self.subsubsub.create({ - 'name': 'subsubsub', - 'subfield': 'level3', - 'subsubfield': 'ssfcontent2', - 'subsubsubfield': 'sssfcontent', - }) - overridden_id = self.overridden.create({ - 'name': 'overridden', - 'subfield': 3, - }) + parent_id, = self.parent.create([{'name': 'parent'}]) + sub_id, = self.sub.create([{ + 'name': 'sub', + 'subfield': 'level1', + }]) + subsub_id, = self.subsub.create([{ + 'name': 'subsub', + 'subfield': 'level2', + 'subsubfield': 'ssfcontent', + }]) + subsubsub_id, = self.subsubsub.create([{ + 'name': 'subsubsub', + 'subfield': 'level3', + 'subsubfield': 'ssfcontent2', + 'subsubsubfield': 'sssfcontent', + }]) + overridden_id, = self.overridden.create([{ + 'name': 'overridden', + 'subfield': 3, + }]) return (parent_id, sub_id, subsub_id, subsubsub_id, overridden_id) def test0010selfsearch(self): diff --git a/trytond/tests/test_modelsingleton.py b/trytond/tests/test_modelsingleton.py index 3b4bad23c9..915bb3748d 100644 --- a/trytond/tests/test_modelsingleton.py +++ b/trytond/tests/test_modelsingleton.py @@ -51,11 +51,11 @@ class ModelSingletonTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - singleton = self.singleton.create({'name': 'bar'}) + singleton, = self.singleton.create([{'name': 'bar'}]) self.assert_(singleton) self.assertEqual(singleton.name, 'bar') - singleton2 = self.singleton.create({'name': 'foo'}) + singleton2, = self.singleton.create([{'name': 'foo'}]) self.assertEqual(singleton2, singleton) self.assertEqual(singleton.name, 'foo') @@ -103,7 +103,7 @@ class ModelSingletonTestCase(unittest.TestCase): with_rec_name=False) self.assertEqual(len(default), 1) - self.singleton.create({'name': 'bar'}) + self.singleton.create([{'name': 'bar'}]) default = self.singleton.default_get(['name']) self.assertEqual(default, {'name': 'bar'}) diff --git a/trytond/tests/test_modelsql.py b/trytond/tests/test_modelsql.py index f2ea235d6c..2419a6094d 100644 --- a/trytond/tests/test_modelsql.py +++ b/trytond/tests/test_modelsql.py @@ -37,7 +37,7 @@ class ModelSQLTestCase(unittest.TestCase): for key, value in fields.iteritems(): with Transaction().start(DB_NAME, USER, context=CONTEXT): try: - self.modelsql.create({key: value}) + self.modelsql.create([{key: value}]) except UserError, err: # message must not quote key msg = "'%s' not missing but quoted in error: '%s'" % (key, diff --git a/trytond/tests/test_mptt.py b/trytond/tests/test_mptt.py index 17fc57728a..62554b6e9c 100644 --- a/trytond/tests/test_mptt.py +++ b/trytond/tests/test_mptt.py @@ -102,12 +102,11 @@ class MPTTTestCase(unittest.TestCase): k = 0 for parent_record in parent_records: for i in range(3): - record = self.mptt.create({ - 'name': 'Test %d %d %d' % (j, k, i), - 'parent': (parent_record.id - if parent_record else None), - }) - new_records.append(record) + new_records += self.mptt.create([{ + 'name': 'Test %d %d %d' % (j, k, i), + 'parent': (parent_record.id + if parent_record else None), + }]) k += 1 self.CheckTree() diff --git a/trytond/tests/test_sequence.py b/trytond/tests/test_sequence.py index abb6290cf6..ab0454ea34 100644 --- a/trytond/tests/test_sequence.py +++ b/trytond/tests/test_sequence.py @@ -24,13 +24,13 @@ class SequenceTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - sequence = self.sequence.create({ - 'name': 'Test incremental', - 'code': 'test', - 'prefix': '', - 'suffix': '', - 'type': 'incremental', - }) + sequence, = self.sequence.create([{ + 'name': 'Test incremental', + 'code': 'test', + 'prefix': '', + 'suffix': '', + 'type': 'incremental', + }]) self.assertEqual(self.sequence.get_id(sequence), '1') self.sequence.write([sequence], { @@ -52,13 +52,13 @@ class SequenceTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - sequence = self.sequence.create({ - 'name': 'Test decimal timestamp', - 'code': 'test', - 'prefix': '', - 'suffix': '', - 'type': 'decimal timestamp', - }) + sequence, = self.sequence.create([{ + 'name': 'Test decimal timestamp', + 'code': 'test', + 'prefix': '', + 'suffix': '', + 'type': 'decimal timestamp', + }]) timestamp = self.sequence.get_id(sequence) self.assertEqual(timestamp, str(sequence.last_timestamp)) @@ -77,13 +77,13 @@ class SequenceTestCase(unittest.TestCase): ''' with Transaction().start(DB_NAME, USER, context=CONTEXT) as transaction: - sequence = self.sequence.create({ - 'name': 'Test hexadecimal timestamp', - 'code': 'test', - 'prefix': '', - 'suffix': '', - 'type': 'hexadecimal timestamp', - }) + sequence, = self.sequence.create([{ + 'name': 'Test hexadecimal timestamp', + 'code': 'test', + 'prefix': '', + 'suffix': '', + 'type': 'hexadecimal timestamp', + }]) timestamp = self.sequence.get_id(sequence) self.assertEqual(timestamp, hex(int(sequence.last_timestamp))[2:].upper()) @@ -102,13 +102,13 @@ class SequenceTestCase(unittest.TestCase): Test prefix/suffix ''' with Transaction().start(DB_NAME, USER, context=CONTEXT): - sequence = self.sequence.create({ - 'name': 'Test incremental', - 'code': 'test', - 'prefix': 'prefix/', - 'suffix': '/suffix', - 'type': 'incremental', - }) + sequence, = self.sequence.create([{ + 'name': 'Test incremental', + 'code': 'test', + 'prefix': 'prefix/', + 'suffix': '/suffix', + 'type': 'incremental', + }]) self.assertEqual(self.sequence.get_id(sequence), 'prefix/1/suffix') diff --git a/trytond/tests/test_trigger.py b/trytond/tests/test_trigger.py index f9f0b3a69a..c12642497c 100644 --- a/trytond/tests/test_trigger.py +++ b/trytond/tests/test_trigger.py @@ -61,7 +61,7 @@ class TriggerTestCase(unittest.TestCase): 'action_model': model.id, 'action_function': 'test', } - self.assert_(self.trigger.create(values)) + self.assert_(self.trigger.create([values])) # on_exclusive for i in range(1, 4): @@ -71,13 +71,13 @@ class TriggerTestCase(unittest.TestCase): for mode in combination: combination_values['on_%s' % mode] = True self.assertRaises(Exception, self.trigger.create, - combination_values) + [combination_values]) # check_condition condition_values = values.copy() condition_values['condition'] = '=' self.assertRaises(Exception, self.trigger.create, - condition_values) + [condition_values]) # Restart the cache on the get_triggers method of ir.trigger self.trigger._get_triggers_cache.clear() @@ -93,18 +93,18 @@ class TriggerTestCase(unittest.TestCase): ('model', '=', 'test.triggered'), ]) - trigger = self.trigger.create({ - 'name': 'Test', - 'model': model.id, - 'on_create': True, - 'condition': 'True', - 'action_model': model.id, - 'action_function': 'trigger', - }) + trigger, = self.trigger.create([{ + 'name': 'Test', + 'model': model.id, + 'on_create': True, + 'condition': 'True', + 'action_model': model.id, + 'action_function': 'trigger', + }]) - triggered = self.triggered.create({ - 'name': 'Test', - }) + triggered, = self.triggered.create([{ + 'name': 'Test', + }]) self.assertEqual(TRIGGER_LOGS, [([triggered], trigger)]) TRIGGER_LOGS.pop() @@ -115,16 +115,16 @@ class TriggerTestCase(unittest.TestCase): }) # Matching condition - triggered = self.triggered.create({ - 'name': 'Bar', - }) + triggered, = self.triggered.create([{ + 'name': 'Bar', + }]) self.assertEqual(TRIGGER_LOGS, [([triggered], trigger)]) TRIGGER_LOGS.pop() # Non matching condition - triggered = self.triggered.create({ - 'name': 'Foo', - }) + triggered, = self.triggered.create([{ + 'name': 'Foo', + }]) self.assertEqual(TRIGGER_LOGS, []) # With limit number @@ -132,9 +132,9 @@ class TriggerTestCase(unittest.TestCase): 'condition': 'True', 'limit_number': 1, }) - triggered = self.triggered.create({ - 'name': 'Test', - }) + triggered, = self.triggered.create([{ + 'name': 'Test', + }]) self.assertEqual(TRIGGER_LOGS, [([triggered], trigger)]) TRIGGER_LOGS.pop() @@ -143,9 +143,9 @@ class TriggerTestCase(unittest.TestCase): 'limit_number': 0, 'minimum_delay': 1, }) - triggered = self.triggered.create({ - 'name': 'Test', - }) + triggered, = self.triggered.create([{ + 'name': 'Test', + }]) self.assertEqual(TRIGGER_LOGS, [([triggered], trigger)]) TRIGGER_LOGS.pop() @@ -163,18 +163,18 @@ class TriggerTestCase(unittest.TestCase): ('model', '=', 'test.triggered'), ]) - trigger = self.trigger.create({ - 'name': 'Test', - 'model': model.id, - 'on_write': True, - 'condition': 'True', - 'action_model': model.id, - 'action_function': 'trigger', - }) + trigger, = self.trigger.create([{ + 'name': 'Test', + 'model': model.id, + 'on_write': True, + 'condition': 'True', + 'action_model': model.id, + 'action_function': 'trigger', + }]) - triggered = self.triggered.create({ - 'name': 'Test', - }) + triggered, = self.triggered.create([{ + 'name': 'Test', + }]) self.triggered.write([triggered], { 'name': 'Foo', @@ -210,9 +210,9 @@ class TriggerTestCase(unittest.TestCase): 'condition': 'self.name == "Bar"', 'limit_number': 1, }) - triggered = self.triggered.create({ - 'name': 'Foo', - }) + triggered, = self.triggered.create([{ + 'name': 'Foo', + }]) self.triggered.write([triggered], { 'name': 'Bar', }) @@ -230,9 +230,9 @@ class TriggerTestCase(unittest.TestCase): 'limit_number': 0, 'minimum_delay': MAXINT, }) - triggered = self.triggered.create({ - 'name': 'Foo', - }) + triggered, = self.triggered.create([{ + 'name': 'Foo', + }]) for name in ('Bar', 'Foo', 'Bar'): self.triggered.write([triggered], { 'name': name, @@ -243,9 +243,9 @@ class TriggerTestCase(unittest.TestCase): self.trigger.write([trigger], { 'minimum_delay': 0.02, }) - triggered = self.triggered.create({ - 'name': 'Foo', - }) + triggered, = self.triggered.create([{ + 'name': 'Foo', + }]) for name in ('Bar', 'Foo'): self.triggered.write([triggered], { 'name': name, @@ -273,18 +273,18 @@ class TriggerTestCase(unittest.TestCase): ('model', '=', 'test.triggered'), ]) - triggered = self.triggered.create({ - 'name': 'Test', - }) + triggered, = self.triggered.create([{ + 'name': 'Test', + }]) - trigger = self.trigger.create({ - 'name': 'Test', - 'model': model.id, - 'on_delete': True, - 'condition': 'True', - 'action_model': model.id, - 'action_function': 'trigger', - }) + trigger, = self.trigger.create([{ + 'name': 'Test', + 'model': model.id, + 'on_delete': True, + 'condition': 'True', + 'action_model': model.id, + 'action_function': 'trigger', + }]) self.triggered.delete([triggered]) self.assertEqual(TRIGGER_LOGS, [([triggered], trigger)]) @@ -296,9 +296,9 @@ class TriggerTestCase(unittest.TestCase): 'condition': 'self.name == "Bar"', }) - triggered = self.triggered.create({ - 'name': 'Bar', - }) + triggered, = self.triggered.create([{ + 'name': 'Bar', + }]) # Matching condition self.triggered.delete([triggered]) @@ -306,18 +306,18 @@ class TriggerTestCase(unittest.TestCase): TRIGGER_LOGS.pop() Transaction().delete = {} - triggered = self.triggered.create({ - 'name': 'Foo', - }) + triggered, = self.triggered.create([{ + 'name': 'Foo', + }]) # Non matching condition self.triggered.delete([triggered]) self.assertEqual(TRIGGER_LOGS, []) Transaction().delete = {} - triggered = self.triggered.create({ - 'name': 'Test', - }) + triggered, = self.triggered.create([{ + 'name': 'Test', + }]) # With limit number self.trigger.write([trigger], { @@ -333,9 +333,9 @@ class TriggerTestCase(unittest.TestCase): ('trigger', '=', trigger.id), ])) - triggered = self.triggered.create({ - 'name': 'Test', - }) + triggered, = self.triggered.create([{ + 'name': 'Test', + }]) # With minimum delay self.trigger.write([trigger], { @@ -361,18 +361,18 @@ class TriggerTestCase(unittest.TestCase): ('model', '=', 'test.triggered'), ]) - trigger = self.trigger.create({ - 'name': 'Test', - 'model': model.id, - 'on_time': True, - 'condition': 'True', - 'action_model': model.id, - 'action_function': 'trigger', - }) + trigger, = self.trigger.create([{ + 'name': 'Test', + 'model': model.id, + 'on_time': True, + 'condition': 'True', + 'action_model': model.id, + 'action_function': 'trigger', + }]) - triggered = self.triggered.create({ - 'name': 'Test', - }) + triggered, = self.triggered.create([{ + 'name': 'Test', + }]) self.trigger.trigger_time() self.assert_(TRIGGER_LOGS == [([triggered], trigger)]) TRIGGER_LOGS.pop() diff --git a/trytond/tests/test_wizard.py b/trytond/tests/test_wizard.py index 9a753364e4..a191698787 100644 --- a/trytond/tests/test_wizard.py +++ b/trytond/tests/test_wizard.py @@ -31,7 +31,7 @@ class WizardTestCase(unittest.TestCase): def test0030session(self): 'Session Wizard' with Transaction().start(DB_NAME, USER, CONTEXT): - session_id = self.session.create({}) + session_id, = self.session.create([{}]) session = self.wizard(session_id) self.assertEqual(session.start.id, None) self.assertRaises(AttributeError, getattr, session.start, 'name') @@ -40,12 +40,12 @@ class WizardTestCase(unittest.TestCase): self.assertRaises(AttributeError, getattr, session.start, 'user') self.assertEqual(hasattr(session.start, 'user'), False) session.start.user = USER - group_a = self.group.create({ - 'name': 'Group A', - }) - group_b = self.group.create({ - 'name': 'Group B', - }) + group_a, = self.group.create([{ + 'name': 'Group A', + }]) + group_b, = self.group.create([{ + 'name': 'Group B', + }]) session.start.groups = [ group_a, group_b, diff --git a/trytond/tests/test_workflow.py b/trytond/tests/test_workflow.py index d75ab8ddc2..7d11a23663 100644 --- a/trytond/tests/test_workflow.py +++ b/trytond/tests/test_workflow.py @@ -18,7 +18,7 @@ class WorkflowTestCase(unittest.TestCase): def test0010transition(self): 'Test transition' with Transaction().start(DB_NAME, USER, context=CONTEXT): - wkf = self.workflow.create({}) + wkf, = self.workflow.create([{}]) self.workflow.run([wkf]) self.assertEqual(wkf.state, 'running') diff --git a/trytond/webdav/webdav.py b/trytond/webdav/webdav.py index 24663e46bd..8972c9023e 100644 --- a/trytond/webdav/webdav.py +++ b/trytond/webdav/webdav.py @@ -548,11 +548,11 @@ class Collection(ModelSQL, ModelView): if not object_id2: name = get_urifilename(uri) try: - Attachment.create({ - 'name': name, - 'data': data, - 'resource': '%s,%s' % (object_name, object_id), - }) + Attachment.create([{ + 'name': name, + 'data': data, + 'resource': '%s,%s' % (object_name, object_id), + }]) except Exception: raise DAV_Forbidden else: @@ -576,10 +576,10 @@ class Collection(ModelSQL, ModelView): raise DAV_Forbidden name = get_urifilename(uri) try: - cls.create({ - 'name': name, - 'parent': object_id, - }) + cls.create([{ + 'name': name, + 'parent': object_id, + }]) except Exception: raise DAV_Forbidden return 201 @@ -790,9 +790,14 @@ class Attachment(ModelSQL, ModelView): for action in value: if action[0] == 'create': + to_create = [] for attachment in attachments: - action[1]['path'] = attachment.path - Share.create(action[1]) + for values in action[1]: + values = values.copy() + values['path'] = attachment.path + to_create.append(values) + if to_create: + Share.create(to_create) elif action[0] == 'write': Share.write(action[1], action[2]) elif action[0] == 'delete': diff --git a/trytond/wizard/wizard.py b/trytond/wizard/wizard.py index 78c767457a..1cb98cb246 100644 --- a/trytond/wizard/wizard.py +++ b/trytond/wizard/wizard.py @@ -227,7 +227,7 @@ class Wizard(WarningErrorMixin, URLMixin): def create(cls): "Create a session" Session = Pool().get('ir.session.wizard') - return (Session.create({}).id, cls.start_state, cls.end_state) + return (Session.create([{}])[0].id, cls.start_state, cls.end_state) @classmethod def delete(cls, session_id):