~openerp-usertesting/openobject-server/trunk-muilti_address-rmu

# -*- coding: utf-8 -*-

##############################################################################

#

#    OpenERP, Open Source Management Solution

#    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).

#

#    This program is free software: you can redistribute it and/or modify

#    it under the terms of the GNU Affero General Public License as

#    published by the Free Software Foundation, either version 3 of the

#    License, or (at your option) any later version.

#

#    This program is distributed in the hope that it will be useful,

#    but WITHOUT ANY WARRANTY; without even the implied warranty of

#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

#    GNU Affero General Public License for more details.

#

#    You should have received a copy of the GNU Affero General Public License

#    along with this program.  If not, see <http://www.gnu.org/licenses/>.

#

##############################################################################

"""

  Object relational mapping to database (postgresql) module

     * Hierarchical structure

     * Constraints consistency, validations

     * Object meta Data depends on its status

     * Optimised processing by complex query (multiple actions at once)

     * Default fields value

     * Permissions optimisation

     * Persistant object: DB postgresql

     * Datas conversions

     * Multi-level caching system

     * 2 different inheritancies

     * Fields:

          - classicals (varchar, integer, boolean, ...)

          - relations (one2many, many2one, many2many)

          - functions

"""

import babel.dates

import calendar

import collections

import copy

import datetime

import itertools

import logging

import operator

import pickle

import re

import simplejson

import time

import traceback

import types

import psycopg2

from lxml import etree

import fields

import openerp

import openerp.tools as tools

from openerp.tools.config import config

from openerp.tools.misc import CountingStream

from openerp.tools.safe_eval import safe_eval as eval

from openerp.tools.translate import _

from openerp import SUPERUSER_ID

from query import Query

_logger = logging.getLogger(__name__)

_schema = logging.getLogger(__name__ + '.schema')

# List of etree._Element subclasses that we choose to ignore when parsing XML.

from openerp.tools import SKIPPED_ELEMENT_TYPES

regex_order = re.compile('^(([a-z0-9_]+|"[a-z0-9_]+")( *desc| *asc)?( *, *|))+$', re.I)

regex_object_name = re.compile(r'^[a-z0-9_.]+$')

def transfer_field_to_modifiers(field, modifiers):

    default_values = {}

    state_exceptions = {}

    for attr in ('invisible', 'readonly', 'required'):

        state_exceptions[attr] = []

        default_values[attr] = bool(field.get(attr))

    for state, modifs in (field.get("states",{})).items():

        for modif in modifs:

            if default_values[modif[0]] != modif[1]:

                state_exceptions[modif[0]].append(state)

    for attr, default_value in default_values.items():

        if state_exceptions[attr]:

            modifiers[attr] = [("state", "not in" if default_value else "in", state_exceptions[attr])]

        else:

            modifiers[attr] = default_value

# Don't deal with groups, it is done by check_group().

# Need the context to evaluate the invisible attribute on tree views.

# For non-tree views, the context shouldn't be given.

def transfer_node_to_modifiers(node, modifiers, context=None, in_tree_view=False):

    if node.get('attrs'):

        modifiers.update(eval(node.get('attrs')))

    if node.get('states'):

        if 'invisible' in modifiers and isinstance(modifiers['invisible'], list):

            # TODO combine with AND or OR, use implicit AND for now.

            modifiers['invisible'].append(('state', 'not in', node.get('states').split(',')))

        else:

            modifiers['invisible'] = [('state', 'not in', node.get('states').split(','))]

    for a in ('invisible', 'readonly', 'required'):

        if node.get(a):

            v = bool(eval(node.get(a), {'context': context or {}}))

            if in_tree_view and a == 'invisible':

                # Invisible in a tree view has a specific meaning, make it a

                # new key in the modifiers attribute.

                modifiers['tree_invisible'] = v

            elif v or (a not in modifiers or not isinstance(modifiers[a], list)):

                # Don't set the attribute to False if a dynamic value was

                # provided (i.e. a domain from attrs or states).

                modifiers[a] = v

def simplify_modifiers(modifiers):

    for a in ('invisible', 'readonly', 'required'):

        if a in modifiers and not modifiers[a]:

            del modifiers[a]

def transfer_modifiers_to_node(modifiers, node):

    if modifiers:

        simplify_modifiers(modifiers)

        node.set('modifiers', simplejson.dumps(modifiers))

def setup_modifiers(node, field=None, context=None, in_tree_view=False):

    """ Processes node attributes and field descriptors to generate

    the ``modifiers`` node attribute and set it on the provided node.

    Alters its first argument in-place.

    :param node: ``field`` node from an OpenERP view

    :type node: lxml.etree._Element

    :param dict field: field descriptor corresponding to the provided node

    :param dict context: execution context used to evaluate node attributes

    :param bool in_tree_view: triggers the ``tree_invisible`` code

                              path (separate from ``invisible``): in

                              tree view there are two levels of

                              invisibility, cell content (a column is

                              present but the cell itself is not

                              displayed) with ``invisible`` and column

                              invisibility (the whole column is

                              hidden) with ``tree_invisible``.

    :returns: nothing

    """

    modifiers = {}

    if field is not None:

        transfer_field_to_modifiers(field, modifiers)

    transfer_node_to_modifiers(

        node, modifiers, context=context, in_tree_view=in_tree_view)

    transfer_modifiers_to_node(modifiers, node)

def test_modifiers(what, expected):

    modifiers = {}

    if isinstance(what, basestring):

        node = etree.fromstring(what)

        transfer_node_to_modifiers(node, modifiers)

        simplify_modifiers(modifiers)

        json = simplejson.dumps(modifiers)

        assert json == expected, "%s != %s" % (json, expected)

    elif isinstance(what, dict):

        transfer_field_to_modifiers(what, modifiers)

        simplify_modifiers(modifiers)

        json = simplejson.dumps(modifiers)

        assert json == expected, "%s != %s" % (json, expected)

# To use this test:

# import openerp

# openerp.osv.orm.modifiers_tests()

def modifiers_tests():

    test_modifiers('<field name="a"/>', '{}')

    test_modifiers('<field name="a" invisible="1"/>', '{"invisible": true}')

    test_modifiers('<field name="a" readonly="1"/>', '{"readonly": true}')

    test_modifiers('<field name="a" required="1"/>', '{"required": true}')

    test_modifiers('<field name="a" invisible="0"/>', '{}')

    test_modifiers('<field name="a" readonly="0"/>', '{}')

    test_modifiers('<field name="a" required="0"/>', '{}')

    test_modifiers('<field name="a" invisible="1" required="1"/>', '{"invisible": true, "required": true}') # TODO order is not guaranteed

    test_modifiers('<field name="a" invisible="1" required="0"/>', '{"invisible": true}')

    test_modifiers('<field name="a" invisible="0" required="1"/>', '{"required": true}')

    test_modifiers("""<field name="a" attrs="{'invisible': [('b', '=', 'c')]}"/>""", '{"invisible": [["b", "=", "c"]]}')

    # The dictionary is supposed to be the result of fields_get().

    test_modifiers({}, '{}')

    test_modifiers({"invisible": True}, '{"invisible": true}')

    test_modifiers({"invisible": False}, '{}')

def check_object_name(name):

    """ Check if the given name is a valid openerp object name.

        The _name attribute in osv and osv_memory object is subject to

        some restrictions. This function returns True or False whether

        the given name is allowed or not.

        TODO: this is an approximation. The goal in this approximation

        is to disallow uppercase characters (in some places, we quote

        table/column names and in other not, which leads to this kind

        of errors:

            psycopg2.ProgrammingError: relation "xxx" does not exist).

        The same restriction should apply to both osv and osv_memory

        objects for consistency.

    """

    if regex_object_name.match(name) is None:

        return False

    return True

def raise_on_invalid_object_name(name):

    if not check_object_name(name):

        msg = "The _name attribute %s is not valid." % name

        _logger.error(msg)

        raise except_orm('ValueError', msg)

POSTGRES_CONFDELTYPES = {

    'RESTRICT': 'r',

    'NO ACTION': 'a',

    'CASCADE': 'c',

    'SET NULL': 'n',

    'SET DEFAULT': 'd',

}

def intersect(la, lb):

    return filter(lambda x: x in lb, la)

def fix_import_export_id_paths(fieldname):

    """

    Fixes the id fields in import and exports, and splits field paths

    on '/'.

    :param str fieldname: name of the field to import/export

    :return: split field name

    :rtype: list of str

    """

    fixed_db_id = re.sub(r'([^/])\.id', r'\1/.id', fieldname)

    fixed_external_id = re.sub(r'([^/]):id', r'\1/id', fixed_db_id)

    return fixed_external_id.split('/')

class except_orm(Exception):

    def __init__(self, name, value):

        self.name = name

        self.value = value

        self.args = (name, value)

class BrowseRecordError(Exception):

    pass

class browse_null(object):

    """ Readonly python database object browser

    """

    def __init__(self):

        self.id = False

    def __getitem__(self, name):

        return None

    def __getattr__(self, name):

        return None  # XXX: return self ?

    def __int__(self):

        return False

    def __str__(self):

        return ''

    def __nonzero__(self):

        return False

    def __unicode__(self):

        return u''

#

# TODO: execute an object method on browse_record_list

#

class browse_record_list(list):

    """ Collection of browse objects

        Such an instance will be returned when doing a ``browse([ids..])``

        and will be iterable, yielding browse() objects

    """

    def __init__(self, lst, context=None):

        if not context:

            context = {}

        super(browse_record_list, self).__init__(lst)

        self.context = context

class browse_record(object):

    """ An object that behaves like a row of an object's table.

        It has attributes after the columns of the corresponding object.

        Examples::

            uobj = pool.get('res.users')

            user_rec = uobj.browse(cr, uid, 104)

            name = user_rec.name

    """

    def __init__(self, cr, uid, id, table, cache, context=None,

                 list_class=browse_record_list, fields_process=None):

        """

        :param table: the browsed object (inherited from orm)

        :param dict cache: a dictionary of model->field->data to be shared

                           across browse objects, thus reducing the SQL

                           read()s. It can speed up things a lot, but also be

                           disastrous if not discarded after write()/unlink()

                           operations

        :param dict context: dictionary with an optional context

        """

        if fields_process is None:

            fields_process = {}

        if context is None:

            context = {}

        self._list_class = list_class

        self._cr = cr

        self._uid = uid

        self._id = id

        self._table = table # deprecated, use _model!

        self._model = table

        self._table_name = self._table._name

        self.__logger = logging.getLogger('openerp.osv.orm.browse_record.' + self._table_name)

        self._context = context

        self._fields_process = fields_process

        cache.setdefault(table._name, {})

        self._data = cache[table._name]

#        if not (id and isinstance(id, (int, long,))):

#            raise BrowseRecordError(_('Wrong ID for the browse record, got %r, expected an integer.') % (id,))

#        if not table.exists(cr, uid, id, context):

#            raise BrowseRecordError(_('Object %s does not exists') % (self,))

        if id not in self._data:

            self._data[id] = {'id': id}

        self._cache = cache

    def __getitem__(self, name):

        if name == 'id':

            return self._id

        if name not in self._data[self._id]:

            # build the list of fields we will fetch

            # fetch the definition of the field which was asked for

            if name in self._table._columns:

                col = self._table._columns[name]

            elif name in self._table._inherit_fields:

                col = self._table._inherit_fields[name][2]

            elif hasattr(self._table, str(name)):

                attr = getattr(self._table, name)

                if isinstance(attr, (types.MethodType, types.LambdaType, types.FunctionType)):

                    def function_proxy(*args, **kwargs):

                        if 'context' not in kwargs and self._context:

                            kwargs.update(context=self._context)

                        return attr(self._cr, self._uid, [self._id], *args, **kwargs)

                    return function_proxy

                else:

                    return attr

            else:

                error_msg = "Field '%s' does not exist in object '%s'" % (name, self)

                self.__logger.warning(error_msg)

                if self.__logger.isEnabledFor(logging.DEBUG):

                    self.__logger.debug(''.join(traceback.format_stack()))

                raise KeyError(error_msg)

            # if the field is a classic one or a many2one, we'll fetch all classic and many2one fields

            if col._prefetch:

                # gen the list of "local" (ie not inherited) fields which are classic or many2one

                fields_to_fetch = filter(lambda x: x[1]._classic_write, self._table._columns.items())

                # gen the list of inherited fields

                inherits = map(lambda x: (x[0], x[1][2]), self._table._inherit_fields.items())

                # complete the field list with the inherited fields which are classic or many2one

                fields_to_fetch += filter(lambda x: x[1]._classic_write, inherits)

            # otherwise we fetch only that field

            else:

                fields_to_fetch = [(name, col)]

            ids = filter(lambda id: name not in self._data[id], self._data.keys())

            # read the results

            field_names = map(lambda x: x[0], fields_to_fetch)

            field_values = self._table.read(self._cr, self._uid, ids, field_names, context=self._context, load="_classic_write")

            # TODO: improve this, very slow for reports

            if self._fields_process:

                lang = self._context.get('lang', 'en_US') or 'en_US'

                lang_obj_ids = self.pool.get('res.lang').search(self._cr, self._uid, [('code', '=', lang)])

                if not lang_obj_ids:

                    raise Exception(_('Language with code "%s" is not defined in your system !\nDefine it through the Administration menu.') % (lang,))

                lang_obj = self.pool.get('res.lang').browse(self._cr, self._uid, lang_obj_ids[0])

                for field_name, field_column in fields_to_fetch:

                    if field_column._type in self._fields_process:

                        for result_line in field_values:

                            result_line[field_name] = self._fields_process[field_column._type](result_line[field_name])

                            if result_line[field_name]:

                                result_line[field_name].set_value(self._cr, self._uid, result_line[field_name], self, field_column, lang_obj)

            if not field_values:

                # Where did those ids come from? Perhaps old entries in ir_model_dat?

                _logger.warning("No field_values found for ids %s in %s", ids, self)

                raise KeyError('Field %s not found in %s'%(name, self))

            # create browse records for 'remote' objects

            for result_line in field_values:

                new_data = {}

                for field_name, field_column in fields_to_fetch:

                    if field_column._type == 'many2one':

                        if result_line[field_name]:

                            obj = self._table.pool.get(field_column._obj)

                            if isinstance(result_line[field_name], (list, tuple)):

                                value = result_line[field_name][0]

                            else:

                                value = result_line[field_name]

                            if value:

                                # FIXME: this happen when a _inherits object

                                #        overwrite a field of it parent. Need

                                #        testing to be sure we got the right

                                #        object and not the parent one.

                                if not isinstance(value, browse_record):

                                    if obj is None:

                                        # In some cases the target model is not available yet, so we must ignore it,

                                        # which is safe in most cases, this value will just be loaded later when needed.

                                        # This situation can be caused by custom fields that connect objects with m2o without

                                        # respecting module dependencies, causing relationships to be connected to soon when

                                        # the target is not loaded yet.

                                        continue

                                    new_data[field_name] = browse_record(self._cr,

                                        self._uid, value, obj, self._cache,

                                        context=self._context,

                                        list_class=self._list_class,

                                        fields_process=self._fields_process)

                                else:

                                    new_data[field_name] = value

                            else:

                                new_data[field_name] = browse_null()

                        else:

                            new_data[field_name] = browse_null()

                    elif field_column._type in ('one2many', 'many2many') and len(result_line[field_name]):

                        new_data[field_name] = self._list_class([browse_record(self._cr, self._uid, id, self._table.pool.get(field_column._obj), self._cache, context=self._context, list_class=self._list_class, fields_process=self._fields_process) for id in result_line[field_name]], self._context)

                    elif field_column._type == 'reference':

                        if result_line[field_name]:

                            if isinstance(result_line[field_name], browse_record):

                                new_data[field_name] = result_line[field_name]

                            else:

                                ref_obj, ref_id = result_line[field_name].split(',')

                                ref_id = long(ref_id)

                                if ref_id:

                                    obj = self._table.pool.get(ref_obj)

                                    new_data[field_name] = browse_record(self._cr, self._uid, ref_id, obj, self._cache, context=self._context, list_class=self._list_class, fields_process=self._fields_process)

                                else:

                                    new_data[field_name] = browse_null()

                        else:

                            new_data[field_name] = browse_null()

                    else:

                        new_data[field_name] = result_line[field_name]

                self._data[result_line['id']].update(new_data)

        if not name in self._data[self._id]:

            # How did this happen? Could be a missing model due to custom fields used too soon, see above.

            self.__logger.error("Fields to fetch: %s, Field values: %s", field_names, field_values)

            self.__logger.error("Cached: %s, Table: %s", self._data[self._id], self._table)

            raise KeyError(_('Unknown attribute %s in %s ') % (name, self))

        return self._data[self._id][name]

    def __getattr__(self, name):

        try:

            return self[name]

        except KeyError, e:

            import sys

            exc_info = sys.exc_info()

            raise AttributeError, "Got %r while trying to get attribute %s on a %s record." % (e, name, self._table._name), exc_info[2]

    def __contains__(self, name):

        return (name in self._table._columns) or (name in self._table._inherit_fields) or hasattr(self._table, name)

    def __iter__(self):

        raise NotImplementedError("Iteration is not allowed on %s" % self)

    def __hasattr__(self, name):

        return name in self

    def __int__(self):

        return self._id

    def __str__(self):

        return "browse_record(%s, %d)" % (self._table_name, self._id)

    def __eq__(self, other):

        if not isinstance(other, browse_record):

            return False

        return (self._table_name, self._id) == (other._table_name, other._id)

    def __ne__(self, other):

        if not isinstance(other, browse_record):

            return True

        return (self._table_name, self._id) != (other._table_name, other._id)

    # we need to define __unicode__ even though we've already defined __str__

    # because we have overridden __getattr__

    def __unicode__(self):

        return unicode(str(self))

    def __hash__(self):

        return hash((self._table_name, self._id))

    __repr__ = __str__

    def refresh(self):

        """Force refreshing this browse_record's data and all the data of the

           records that belong to the same cache, by emptying the cache completely,

           preserving only the record identifiers (for prefetching optimizations).

        """

        for model, model_cache in self._cache.iteritems():

            # only preserve the ids of the records that were in the cache

            cached_ids = dict([(i, {'id': i}) for i in model_cache.keys()])

            self._cache[model].clear()

            self._cache[model].update(cached_ids)

def pg_varchar(size=0):

    """ Returns the VARCHAR declaration for the provided size:

    * If no size (or an empty or negative size is provided) return an

      'infinite' VARCHAR

    * Otherwise return a VARCHAR(n)

    :type int size: varchar size, optional

    :rtype: str

    """

    if size:

        if not isinstance(size, int):

            raise TypeError("VARCHAR parameter should be an int, got %s"

                            % type(size))

        if size > 0:

            return 'VARCHAR(%d)' % size

    return 'VARCHAR'

FIELDS_TO_PGTYPES = {

    fields.boolean: 'bool',

    fields.integer: 'int4',

    fields.text: 'text',

    fields.html: 'text',

    fields.date: 'date',

    fields.datetime: 'timestamp',

    fields.binary: 'bytea',

    fields.many2one: 'int4',

    fields.serialized: 'text',

}

def get_pg_type(f, type_override=None):

    """

    :param fields._column f: field to get a Postgres type for

    :param type type_override: use the provided type for dispatching instead of the field's own type

    :returns: (postgres_identification_type, postgres_type_specification)

    :rtype: (str, str)

    """

    field_type = type_override or type(f)

    if field_type in FIELDS_TO_PGTYPES:

        pg_type =  (FIELDS_TO_PGTYPES[field_type], FIELDS_TO_PGTYPES[field_type])

    elif issubclass(field_type, fields.float):

        if f.digits:

            pg_type = ('numeric', 'NUMERIC')

        else:

            pg_type = ('float8', 'DOUBLE PRECISION')

    elif issubclass(field_type, (fields.char, fields.reference)):

        pg_type = ('varchar', pg_varchar(f.size))

    elif issubclass(field_type, fields.selection):

        if (isinstance(f.selection, list) and isinstance(f.selection[0][0], int))\

                or getattr(f, 'size', None) == -1:

            pg_type = ('int4', 'INTEGER')

        else:

            pg_type = ('varchar', pg_varchar(getattr(f, 'size', None)))

    elif issubclass(field_type, fields.function):

        if f._type == 'selection':

            pg_type = ('varchar', pg_varchar())

        else:

            pg_type = get_pg_type(f, getattr(fields, f._type))

    else:

        _logger.warning('%s type not supported!', field_type)

        pg_type = None

    return pg_type

class MetaModel(type):

    """ Metaclass for the Model.

    This class is used as the metaclass for the Model class to discover

    the models defined in a module (i.e. without instanciating them).

    If the automatic discovery is not needed, it is possible to set the

    model's _register attribute to False.

    """

    module_to_models = {}

    def __init__(self, name, bases, attrs):

        if not self._register:

            self._register = True

            super(MetaModel, self).__init__(name, bases, attrs)

            return

        # The (OpenERP) module name can be in the `openerp.addons` namespace