Add One2One field

trytond/model/modelsql.py

 #This file is part of Tryton.  The COPYRIGHT file at the top level of
 #this repository contains the full copyright notices and license terms.
 from __future__ import with_statement
 import contextlib
 import datetime
 import re
+from decimal import Decimal
 from trytond.model import ModelStorage
 from trytond.model import fields
 from trytond.backend import FIELDS, TableHandler
 from trytond.backend import DatabaseIntegrityError, Database
 from trytond.tools import reduce_ids
 from trytond.const import OPERATORS
 from trytond.transaction import Transaction
 _RE_UNIQUE = re.compile('UNIQUE\s*\((.*)\)', re.I)
 _RE_CHECK = re.compile('CHECK\s*\((.*)\)', re.I)
 
@@ skipping 360 matching lines @@
                 mode='create')
         if domain1:
             cursor.execute('SELECT id FROM "' + self._table + '" ' \
                     'WHERE id = %s AND (' + domain1 + ')',
                     [id_new] + domain2)
             if not cursor.fetchone():
                 self.raise_user_error('access_error', self._description)
 
         Transaction().create_records.setdefault(self._name, set()).add(id_new)
 
+        for field in values:
+            if getattr(self._columns[field], 'translate', False):
+                self.pool.get('ir.translation')._set_ids(
+                        self._name + ',' + field, 'model',
+                        Transaction().language, [id_new], values[field])
+
         upd_todo.sort(lambda x, y: self._columns[x].priority - \
                 self._columns[y].priority)
         for field in upd_todo:
             self._columns[field].set([id_new], self, field, values[field])
 
         if self._history:
             cursor.execute('INSERT INTO "' + self._table + '__history" ' \
                     '(id' + upd0 + ') ' \
                     'SELECT id' + upd0 + ' ' \
                     'FROM "' + self._table + '" ' \
@@ skipping 79 matching lines @@
             history_clause = ' AND (COALESCE(write_date, create_date) <= %s)'
             history_order = ' ORDER BY COALESCE(write_date, create_date) DESC'
             history_limit = cursor.limit_clause('', 1)
             history_args = [Transaction().context['_datetime']]
         if len(fields_pre) :
             fields_pre2 = ['"%s"."%s" AS "%s"' % (self._table, x, x)
                     for x in fields_pre if x != '_timestamp']
             if '_timestamp' in fields_pre:
                 if not self.table_query():
                     fields_pre2 += ['CAST(EXTRACT(EPOCH FROM '
-                            '(COALESCE("%s".write_date, "%s".create_date))) AS %s'
-                            ') AS _timestamp' %
-                            (self._table, self._table,
-                                FIELDS['numeric'].sql_type(self.create_date)[1])]
+                            '(COALESCE("%s".write_date, "%s".create_date)))'
+                            'AS VARCHAR) AS _timestamp' %
+                            (self._table, self._table)]
 
             for i in range(0, len(ids), in_max):
                 sub_ids = ids[i:i + in_max]
                 red_sql, red_ids = reduce_ids('id', sub_ids)
                 if domain1:
                     cursor.execute('SELECT ' + \
                             ','.join(fields_pre2 +
                                 ['"%s".id AS id' % self._table]) + \
                             ' FROM ' + table_query + '\"' + self._table +'\" ' \
                             'WHERE ' + red_sql  + \
@@ skipping 119 matching lines @@
         to_del = []
         fields_related2values = {}
         for field in fields_related.keys() + datetime_fields:
             if field not in fields_names:
                 to_del.append(field)
             if field not in self._columns:
                 continue
             if field not in fields_related.keys():
                 continue
             fields_related2values.setdefault(field, {})
-            if self._columns[field]._type == 'many2one':
-                obj = self.pool.get(self._columns[field].model_name)
+            if self._columns[field]._type in ('many2one', 'one2one'):
+                if hasattr(self._columns[field], 'model_name'):
+                    obj = self.pool.get(self._columns[field].model_name)
+                else:
+                    obj = self._columns[field].get_target(self.pool)
                 if hasattr(self._columns[field], 'datetime_field') \
                         and self._columns[field].datetime_field:
                     for record in res:
                         if not record[field]:
                             continue
                         with Transaction().set_context(_datetime=
                                 record[self._columns[field].datetime_field]):
                             record2 = obj.read(record[field],
                                     fields_related[field])
                         record_id = record2['id']
@@ skipping 24 matching lines @@
                     record2 = obj.read(record_id, fields_related[field])
                     del record2['id']
                     fields_related2values[field][record_id] = record2
 
         if to_del or fields_related.keys() or datetime_fields:
             for record in res:
                 for field in fields_related.keys():
                     if field not in self._columns:
                         continue
                     for related in fields_related[field]:
-                        if self._columns[field]._type == 'many2one':
+                        if self._columns[field]._type in ('many2one', 'one2one'):
                             if record[field]:
                                 record[field + '.' + related] = \
                                         fields_related2values[field]\
                                         [record[field]][record['id']][related]
                             else:
                                 record[field + '.' + related] = False
                         elif self._columns[field]._type == 'reference':
                             if record[field]:
                                 model_name, record_id = record[field].split(
                                         ',', 1)
@@ skipping 50 matching lines @@
                 sub_ids = ids[i:i + cursor.IN_MAX]
                 clause = ('(id = %s AND '
                         'CAST(EXTRACT(EPOCH FROM '
                         'COALESCE(write_date, create_date)) AS ' + \
                         FIELDS['numeric'].sql_type(self.create_date)[1] + \
                         ') > %s)')
                 args = []
                 for i in sub_ids:
                     if Transaction().timestamp.get(self._name + ',' + str(i)):
                         args.append(i)
-                        args.append(Transaction().timestamp[
-                            self._name + ',' +str(i)])
+                        args.append(Decimal(Transaction().timestamp[
+                            self._name + ',' +str(i)]))
                 if args:
                     cursor.execute("SELECT id " \
                             'FROM "' + self._table + '" ' \
                             'WHERE ' + ' OR '.join(
                                 (clause,) * (len(args)/2)), args)
                     if cursor.fetchone():
                         raise Exception('ConcurrencyException',
                                 'Records were modified in the meanwhile')
             for i in ids:
                 if Transaction().timestamp.get(self._name + ',' + str(i)):
@@ skipping 338 matching lines @@
                             self.raise_user_error(error)
                     for name, error in self._sql_error_messages:
                         if name in exception[0]:
                             self.raise_user_error(error)
                 raise
 
         if self._history:
             for obj_id in ids:
                 cursor.execute('INSERT INTO "' + self._table + '__history" ' \
                         '(id, write_uid, write_date) VALUES (%s, %s, %s)',
-                        (obj_id, user, datetime.datetime.now()))
+                        (obj_id, Transaction().user, datetime.datetime.now()))
 
         for k in tree_ids.keys():
             field = self._columns[k]
             if len(tree_ids[k]) == 1:
                 self._update_tree(tree_ids[k][0], k, field.left, field.right)
             else:
                 with Transaction().set_user(0):
                     self._rebuild_tree(k, False, 0)
 
         return True
@@ skipping 54 matching lines @@
             select_fields += [
                     '"' + self._table + '"."' + x[0] + '" AS "' + x[0] + '"' \
                     for x in self._columns.iteritems() \
                     if not hasattr(x[1], 'get') \
                     and (x[0] != 'id')
                     and (not getattr(x[1], 'translate', False) \
                         and x[1]._type not in ('text', 'binary'))]
             if not self.table_query():
                 select_fields += ['CAST(EXTRACT(EPOCH FROM '
                         '(COALESCE("' + self._table + '".write_date, '
-                        '"' + self._table + '".create_date))) AS ' + \
-                        FIELDS['numeric'].sql_type(self.create_date)[1] + \
+                        '"' + self._table + '".create_date))) AS VARCHAR'
                         ') AS _timestamp']
         query_str = cursor.limit_clause(
                 'SELECT ' + ','.join(select_fields) + ' FROM ' + \
                 ' '.join(tables) + (qu1 and ' WHERE ' + qu1 or '') + \
                 (order_by and ' ORDER BY ' + order_by or ''), limit, offset)
         if query_string:
             return (query_str, tables_args + qu2)
         cursor.execute(query_str, tables_args + qu2)
 
         datas = cursor.dictfetchmany(cursor.IN_MAX)
@@ skipping 988 matching lines @@
                 for i in range(0, len(ids), cursor.IN_MAX):
                     sub_ids = ids[i:i + cursor.IN_MAX]
                     red_sql, red_ids = reduce_ids('id', sub_ids)
                     cursor.execute('SELECT id ' \
                             'FROM "' + self._table + '" ' \
                             'WHERE NOT (' + sql + ') ' \
                                 'AND ' + red_sql, red_ids)
                     if cursor.fetchone():
                         self.raise_user_error(error)
                     continue