You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
167 lines
6.9 KiB
167 lines
6.9 KiB
# -*- coding: utf-8 -*-
|
|
# © 2014-2017 Therp BV <http://therp.nl>.
|
|
# License AGPL-3.0 or later <http://www.gnu.org/licenses/agpl.html>.
|
|
from psycopg2.extensions import AsIs
|
|
|
|
from openerp.osv import fields
|
|
from openerp.osv import orm
|
|
from openerp.tools import drop_view_if_exists
|
|
from .res_partner_relation_type import ResPartnerRelationType
|
|
|
|
|
|
_RECORD_TYPES = [
|
|
('a', 'Type'),
|
|
('b', 'Inverse type'),
|
|
]
|
|
|
|
|
|
class ResPartnerRelationTypeSelection(orm.Model):
|
|
"""Virtual relation types.
|
|
|
|
For the model defined here _auto is set to False to prevent creating a
|
|
database file. All i/o operations are overridden to use a sql SELECT that
|
|
takes data from res_partner_connection_type where each type is included
|
|
in the result set twice, so it appears that the connection type and
|
|
the inverse type are separate records..
|
|
|
|
The original function _auto_init is still called because this function
|
|
normally (if _auto == True) not only creates the db tables, but it also
|
|
takes care of registering all fields in ir_model_fields. This is needed
|
|
to make the field labels translatable.
|
|
|
|
example content for last lines of _statement:
|
|
select id, record_type,
|
|
customer_id, customer_name, customer_city, customer_zip, customer_street,
|
|
caller_id, caller_name, caller_phone, caller_fax, caller_email
|
|
from FULL_LIST as ResPartnerRelationTypeSelection where record_type = 'c'
|
|
ORDER BY ResPartnerRelationTypeSelection.customer_name asc,
|
|
ResPartnerRelationTypeSelection.caller_name asc;
|
|
"""
|
|
_auto = False # Do not try to create table in _auto_init(..)
|
|
_log_access = False
|
|
|
|
def get_type_from_selection_id(self, cr, uid, selection_id):
|
|
"""Selection id ic computed from id of underlying type and the
|
|
kind of record. This function does the inverse computation to give
|
|
back the original type id, and about the record type."""
|
|
type_id = selection_id / 10
|
|
is_reverse = (selection_id % 10) > 0
|
|
return (type_id, is_reverse)
|
|
|
|
def _auto_init(self, cr, context=None):
|
|
"""Create view instead of table."""
|
|
drop_view_if_exists(cr, self._table)
|
|
# TODO: we lose field value's translations here.
|
|
# probably we need to patch ir_translation.get_source for that
|
|
# to get res_partner_relation_type's translations
|
|
cr.execute(
|
|
"""create or replace view %s as
|
|
select
|
|
id * 10 as id,
|
|
id as type_id,
|
|
cast('a' as char(1)) as record_type,
|
|
name as name,
|
|
contact_type_left as contact_type_this,
|
|
contact_type_right as contact_type_other,
|
|
partner_category_left as partner_category_this,
|
|
partner_category_right as partner_category_other
|
|
from res_partner_relation_type
|
|
union select
|
|
id * 10 + 1,
|
|
id,
|
|
cast('b' as char(1)),
|
|
name_inverse,
|
|
contact_type_right,
|
|
contact_type_left,
|
|
partner_category_right,
|
|
partner_category_left
|
|
from res_partner_relation_type
|
|
""",
|
|
params=(
|
|
AsIs(self._table),
|
|
)
|
|
)
|
|
return super(ResPartnerRelationTypeSelection, self)._auto_init(
|
|
cr, context=context)
|
|
|
|
def _search_partner_category_this(
|
|
self, cr, uid, obj, field_name, args, context=None):
|
|
category_ids = []
|
|
for arg in args:
|
|
if isinstance(arg, tuple) and arg[0] == field_name\
|
|
and (arg[1] == '=' or arg[1] == 'in'):
|
|
# TODO don't we have an api function to eval that?
|
|
for delta in arg[2]:
|
|
if delta[0] == 6:
|
|
category_ids.extend(delta[2])
|
|
if category_ids:
|
|
return [
|
|
'|',
|
|
('partner_category_this', '=', False),
|
|
('partner_category_this', 'in', category_ids),
|
|
]
|
|
else:
|
|
return [('partner_category_this', '=', False)]
|
|
|
|
_name = 'res.partner.relation.type.selection'
|
|
_description = 'All relation types'
|
|
_foreign_keys = []
|
|
_columns = {
|
|
'record_type': fields.selection(_RECORD_TYPES, 'Record type', size=16),
|
|
'type_id': fields.many2one(
|
|
'res.partner.relation.type', 'Type'),
|
|
'name': fields.char('Name', size=64),
|
|
'contact_type_this': fields.selection(
|
|
ResPartnerRelationType._get_partner_types.im_func,
|
|
'Current record\'s partner type'),
|
|
'contact_type_other': fields.selection(
|
|
ResPartnerRelationType._get_partner_types.im_func,
|
|
'Other record\'s partner type'),
|
|
'partner_category_this': fields.many2one(
|
|
'res.partner.category', 'Current record\'s category'),
|
|
'partner_category_other': fields.many2one(
|
|
'res.partner.category', 'Other record\'s category'),
|
|
# search field to handle many2many deltas from the client
|
|
'search_partner_category_this': fields.function(
|
|
lambda self, cr, uid, ids, context=None: dict(
|
|
[(i, False) for i in ids]),
|
|
fnct_search=_search_partner_category_this,
|
|
type='many2many', obj='res.partner.category',
|
|
string='Current record\'s category'),
|
|
}
|
|
_order = 'name asc'
|
|
|
|
def name_get(self, cr, uid, ids, context=None):
|
|
'translate name using translations from res.partner.relation.type'
|
|
context = context or {'lang': 'en_US'} # prevent crash later
|
|
result = super(ResPartnerRelationTypeSelection, self).name_get(
|
|
cr, uid, ids, context=context)
|
|
ir_translation = self.pool['ir.translation']
|
|
return [
|
|
(i, ir_translation._get_source(
|
|
cr, uid,
|
|
'res.partner.relation.type,name_inverse'
|
|
if self.get_type_from_selection_id(cr, uid, i)[1]
|
|
else 'res.partner.relation.type,name',
|
|
'model', context.get('lang'), name))
|
|
for i, name in result]
|
|
|
|
def name_search(self, cr, uid, name='', args=None, operator='ilike',
|
|
context=None, limit=100):
|
|
'search for translated names in res.partner.relation.type'
|
|
res_partner_relation_type = self.pool['res.partner.relation.type']
|
|
relation_ids = res_partner_relation_type.search(
|
|
cr, uid, [('name', operator, name)],
|
|
context=context)
|
|
inverse_relation_ids = res_partner_relation_type.search(
|
|
cr, uid, [('name_inverse', operator, name)],
|
|
context=context)
|
|
all_ids = self.search(
|
|
cr, uid,
|
|
[
|
|
('id', 'in',
|
|
map(lambda x: x * 10, relation_ids) +
|
|
map(lambda x: x * 10 + 1, inverse_relation_ids)),
|
|
] + (args or []),
|
|
context=context, limit=limit)
|
|
return self.name_get(cr, uid, all_ids, context=context)
|