1 # -*- coding: utf-8 -*-
2 ##############################################################################
4 # OpenERP, Open Source Management Solution
5 # Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
7 # This program is free software: you can redistribute it and/or modify
8 # it under the terms of the GNU Affero General Public License as
9 # published by the Free Software Foundation, either version 3 of the
10 # License, or (at your option) any later version.
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU Affero General Public License for more details.
17 # You should have received a copy of the GNU Affero General Public License
18 # along with this program. If not, see <http://www.gnu.org/licenses/>.
20 ##############################################################################
23 from lxml import etree
28 from openerp import SUPERUSER_ID
29 from openerp import tools
30 from openerp.osv import osv, fields
31 from openerp.osv.expression import get_unaccent_wrapper
32 from openerp.tools.translate import _
34 class format_address(object):
35 def fields_view_get_address(self, cr, uid, arch, context={}):
36 user_obj = self.pool['res.users']
37 fmt = user_obj.browse(cr, SUPERUSER_ID, uid, context).company_id.country_id
38 fmt = fmt and fmt.address_format
40 '%(city)s %(state_code)s\n%(zip)s': """
41 <div class="address_format">
42 <field name="city" placeholder="City" style="width: 50%%"/>
43 <field name="state_id" class="oe_no_button" placeholder="State" style="width: 47%%" options='{"no_open": true}'/>
45 <field name="zip" placeholder="ZIP"/>
48 '%(zip)s %(city)s': """
49 <div class="address_format">
50 <field name="zip" placeholder="ZIP" style="width: 40%%"/>
51 <field name="city" placeholder="City" style="width: 57%%"/>
53 <field name="state_id" class="oe_no_button" placeholder="State" options='{"no_open": true}'/>
56 '%(city)s\n%(state_name)s\n%(zip)s': """
57 <div class="address_format">
58 <field name="city" placeholder="City"/>
59 <field name="state_id" class="oe_no_button" placeholder="State" options='{"no_open": true}'/>
60 <field name="zip" placeholder="ZIP"/>
64 for k,v in layouts.items():
65 if fmt and (k in fmt):
66 doc = etree.fromstring(arch)
67 for node in doc.xpath("//div[@class='address_format']"):
68 tree = etree.fromstring(v)
69 node.getparent().replace(node, tree)
70 arch = etree.tostring(doc)
75 def _tz_get(self,cr,uid, context=None):
76 # put POSIX 'Etc/*' entries at the end to avoid confusing users - see bug 1086728
77 return [(tz,tz) for tz in sorted(pytz.all_timezones, key=lambda tz: tz if not tz.startswith('Etc/') else '_')]
79 class res_partner_category(osv.osv):
81 def name_get(self, cr, uid, ids, context=None):
82 """Return the categories' display name, including their direct
85 :param dict context: the ``partner_category_display`` key can be
86 used to select the short version of the
87 category name (without the direct parent),
88 when set to ``'short'``. The default is
92 if context.get('partner_category_display') == 'short':
93 return super(res_partner_category, self).name_get(cr, uid, ids, context=context)
94 if isinstance(ids, (int, long)):
96 reads = self.read(cr, uid, ids, ['name', 'parent_id'], context=context)
100 if record['parent_id']:
101 name = record['parent_id'][1] + ' / ' + name
102 res.append((record['id'], name))
105 def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=100):
111 # Be sure name_search is symetric to name_get
112 name = name.split(' / ')[-1]
113 ids = self.search(cr, uid, [('name', operator, name)] + args, limit=limit, context=context)
115 ids = self.search(cr, uid, args, limit=limit, context=context)
116 return self.name_get(cr, uid, ids, context)
119 def _name_get_fnc(self, cr, uid, ids, prop, unknow_none, context=None):
120 res = self.name_get(cr, uid, ids, context=context)
123 _description = 'Partner Tags'
124 _name = 'res.partner.category'
126 'name': fields.char('Category Name', required=True, size=64, translate=True),
127 'parent_id': fields.many2one('res.partner.category', 'Parent Category', select=True, ondelete='cascade'),
128 'complete_name': fields.function(_name_get_fnc, type="char", string='Full Name'),
129 'child_ids': fields.one2many('res.partner.category', 'parent_id', 'Child Categories'),
130 'active': fields.boolean('Active', help="The active field allows you to hide the category without removing it."),
131 'parent_left': fields.integer('Left parent', select=True),
132 'parent_right': fields.integer('Right parent', select=True),
133 'partner_ids': fields.many2many('res.partner', id1='category_id', id2='partner_id', string='Partners'),
136 (osv.osv._check_recursion, 'Error ! You can not create recursive categories.', ['parent_id'])
142 _parent_order = 'name'
143 _order = 'parent_left'
145 class res_partner_title(osv.osv):
146 _name = 'res.partner.title'
149 'name': fields.char('Title', required=True, size=46, translate=True),
150 'shortcut': fields.char('Abbreviation', size=16, translate=True),
151 'domain': fields.selection([('partner', 'Partner'), ('contact', 'Contact')], 'Domain', required=True, size=24)
157 def _lang_get(self, cr, uid, context=None):
158 lang_pool = self.pool['res.lang']
159 ids = lang_pool.search(cr, uid, [], context=context)
160 res = lang_pool.read(cr, uid, ids, ['code', 'name'], context)
161 return [(r['code'], r['name']) for r in res]
163 # fields copy if 'use_parent_address' is checked
164 ADDRESS_FIELDS = ('street', 'street2', 'zip', 'city', 'state_id', 'country_id')
166 class res_partner(osv.osv, format_address):
167 _description = 'Partner'
168 _name = "res.partner"
170 def _address_display(self, cr, uid, ids, name, args, context=None):
172 for partner in self.browse(cr, uid, ids, context=context):
173 res[partner.id] = self._display_address(cr, uid, partner, context=context)
176 def _get_image(self, cr, uid, ids, name, args, context=None):
177 result = dict.fromkeys(ids, False)
178 for obj in self.browse(cr, uid, ids, context=context):
179 result[obj.id] = tools.image_get_resized_images(obj.image)
182 def _get_tz_offset(self, cr, uid, ids, name, args, context=None):
183 result = dict.fromkeys(ids, False)
184 for obj in self.browse(cr, uid, ids, context=context):
185 result[obj.id] = datetime.datetime.now(pytz.timezone(obj.tz or 'GMT')).strftime('%z')
188 def _set_image(self, cr, uid, id, name, value, args, context=None):
189 return self.write(cr, uid, [id], {'image': tools.image_resize_image_big(value)}, context=context)
191 def _has_image(self, cr, uid, ids, name, args, context=None):
193 for obj in self.browse(cr, uid, ids, context=context):
194 result[obj.id] = obj.image != False
197 def _commercial_partner_compute(self, cr, uid, ids, name, args, context=None):
198 """ Returns the partner that is considered the commercial
199 entity of this partner. The commercial entity holds the master data
200 for all commercial fields (see :py:meth:`~_commercial_fields`) """
201 result = dict.fromkeys(ids, False)
202 for partner in self.browse(cr, uid, ids, context=context):
203 current_partner = partner
204 while not current_partner.is_company and current_partner.parent_id:
205 current_partner = current_partner.parent_id
206 result[partner.id] = current_partner.id
209 def _display_name_compute(self, cr, uid, ids, name, args, context=None):
210 context = dict(context or {})
211 context.pop('show_address', None)
212 context.pop('show_address_only', None)
213 context.pop('show_email', None)
214 return dict(self.name_get(cr, uid, ids, context=context))
216 # indirections to avoid passing a copy of the overridable method when declaring the function field
217 _commercial_partner_id = lambda self, *args, **kwargs: self._commercial_partner_compute(*args, **kwargs)
218 _display_name = lambda self, *args, **kwargs: self._display_name_compute(*args, **kwargs)
220 _commercial_partner_store_triggers = {
221 'res.partner': (lambda self,cr,uid,ids,context=None: self.search(cr, uid, [('id','child_of',ids)], context=dict(active_test=False)),
222 ['parent_id', 'is_company'], 10)
224 _display_name_store_triggers = {
225 'res.partner': (lambda self,cr,uid,ids,context=None: self.search(cr, uid, [('id','child_of',ids)], context=dict(active_test=False)),
226 ['parent_id', 'is_company', 'name'], 10)
229 _order = "display_name"
231 'name': fields.char('Name', size=128, required=True, select=True),
232 'display_name': fields.function(_display_name, type='char', string='Name', store=_display_name_store_triggers, select=True),
233 'date': fields.date('Date', select=1),
234 'title': fields.many2one('res.partner.title', 'Title'),
235 'parent_id': fields.many2one('res.partner', 'Related Company', select=True),
236 'child_ids': fields.one2many('res.partner', 'parent_id', 'Contacts', domain=[('active','=',True)]), # force "active_test" domain to bypass _search() override
237 'ref': fields.char('Reference', size=64, select=1),
238 'lang': fields.selection(_lang_get, 'Language',
239 help="If the selected language is loaded in the system, all documents related to this contact will be printed in this language. If not, it will be English."),
240 'tz': fields.selection(_tz_get, 'Timezone', size=64,
241 help="The partner's timezone, used to output proper date and time values inside printed reports. "
242 "It is important to set a value for this field. You should use the same timezone "
243 "that is otherwise used to pick and render date and time values: your computer's timezone."),
244 'tz_offset': fields.function(_get_tz_offset, type='char', size=5, string='Timezone offset', invisible=True),
245 'user_id': fields.many2one('res.users', 'Salesperson', help='The internal user that is in charge of communicating with this contact if any.'),
246 'vat': fields.char('TIN', size=32, help="Tax Identification Number. Check the box if this contact is subjected to taxes. Used by the some of the legal statements."),
247 'bank_ids': fields.one2many('res.partner.bank', 'partner_id', 'Banks'),
248 'website': fields.char('Website', size=64, help="Website of Partner or Company"),
249 'comment': fields.text('Notes'),
250 'category_id': fields.many2many('res.partner.category', id1='partner_id', id2='category_id', string='Tags'),
251 'credit_limit': fields.float(string='Credit Limit'),
252 'ean13': fields.char('EAN13', size=13),
253 'active': fields.boolean('Active'),
254 'customer': fields.boolean('Customer', help="Check this box if this contact is a customer."),
255 'supplier': fields.boolean('Supplier', help="Check this box if this contact is a supplier. If it's not checked, purchase people will not see it when encoding a purchase order."),
256 'employee': fields.boolean('Employee', help="Check this box if this contact is an Employee."),
257 'function': fields.char('Job Position', size=128),
258 'type': fields.selection([('default', 'Default'), ('invoice', 'Invoice'),
259 ('delivery', 'Shipping'), ('contact', 'Contact'),
260 ('other', 'Other')], 'Address Type',
261 help="Used to select automatically the right address according to the context in sales and purchases documents."),
262 'street': fields.char('Street', size=128),
263 'street2': fields.char('Street2', size=128),
264 'zip': fields.char('Zip', change_default=True, size=24),
265 'city': fields.char('City', size=128),
266 'state_id': fields.many2one("res.country.state", 'State', ondelete='restrict'),
267 'country_id': fields.many2one('res.country', 'Country', ondelete='restrict'),
268 'country': fields.related('country_id', type='many2one', relation='res.country', string='Country',
269 deprecated="This field will be removed as of OpenERP 7.1, use country_id instead"),
270 'email': fields.char('Email', size=240),
271 'phone': fields.char('Phone', size=64),
272 'fax': fields.char('Fax', size=64),
273 'mobile': fields.char('Mobile', size=64),
274 'birthdate': fields.char('Birthdate', size=64),
275 'is_company': fields.boolean('Is a Company', help="Check if the contact is a company, otherwise it is a person"),
276 'use_parent_address': fields.boolean('Use Company Address', help="Select this if you want to set company's address information for this contact"),
277 # image: all image fields are base64 encoded and PIL-supported
278 'image': fields.binary("Image",
279 help="This field holds the image used as avatar for this contact, limited to 1024x1024px"),
280 'image_medium': fields.function(_get_image, fnct_inv=_set_image,
281 string="Medium-sized image", type="binary", multi="_get_image",
283 'res.partner': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
285 help="Medium-sized image of this contact. It is automatically "\
286 "resized as a 128x128px image, with aspect ratio preserved. "\
287 "Use this field in form views or some kanban views."),
288 'image_small': fields.function(_get_image, fnct_inv=_set_image,
289 string="Small-sized image", type="binary", multi="_get_image",
291 'res.partner': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
293 help="Small-sized image of this contact. It is automatically "\
294 "resized as a 64x64px image, with aspect ratio preserved. "\
295 "Use this field anywhere a small image is required."),
296 'has_image': fields.function(_has_image, type="boolean"),
297 'company_id': fields.many2one('res.company', 'Company', select=1),
298 'color': fields.integer('Color Index'),
299 'user_ids': fields.one2many('res.users', 'partner_id', 'Users'),
300 'contact_address': fields.function(_address_display, type='char', string='Complete Address'),
302 # technical field used for managing commercial fields
303 'commercial_partner_id': fields.function(_commercial_partner_id, type='many2one', relation='res.partner', string='Commercial Entity', store=_commercial_partner_store_triggers)
306 def _default_category(self, cr, uid, context=None):
309 if context.get('category_id'):
310 return [context['category_id']]
313 def _get_default_image(self, cr, uid, is_company, context=None, colorize=False):
314 img_path = openerp.modules.get_module_resource('base', 'static/src/img',
315 ('company_image.png' if is_company else 'avatar.png'))
316 with open(img_path, 'rb') as f:
319 # colorize user avatars
321 image = tools.image_colorize(image)
323 return tools.image_resize_image_big(image.encode('base64'))
325 def fields_view_get(self, cr, user, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
326 if (not view_id) and (view_type=='form') and context and context.get('force_email', False):
327 view_id = self.pool['ir.model.data'].get_object_reference(cr, user, 'base', 'view_partner_simple_form')[1]
328 res = super(res_partner,self).fields_view_get(cr, user, view_id, view_type, context, toolbar=toolbar, submenu=submenu)
329 if view_type == 'form':
330 res['arch'] = self.fields_view_get_address(cr, user, res['arch'], context=context)
335 'lang': lambda self, cr, uid, ctx: ctx.get('lang', 'en_US'),
336 'tz': lambda self, cr, uid, ctx: ctx.get('tz', False),
338 'category_id': _default_category,
339 'company_id': lambda self, cr, uid, ctx: self.pool['res.company']._company_default_get(cr, uid, 'res.partner', context=ctx),
342 'type': 'contact', # type 'default' is wildcard and thus inappropriate
343 'use_parent_address': False,
348 (osv.osv._check_recursion, 'You cannot create recursive Partner hierarchies.', ['parent_id']),
351 def copy(self, cr, uid, id, default=None, context=None):
354 default['user_ids'] = False
355 name = self.read(cr, uid, [id], ['name'], context)[0]['name']
356 default.update({'name': _('%s (copy)') % name})
357 return super(res_partner, self).copy(cr, uid, id, default, context)
359 def onchange_type(self, cr, uid, ids, is_company, context=None):
361 value['title'] = False
363 domain = {'title': [('domain', '=', 'partner')]}
365 domain = {'title': [('domain', '=', 'contact')]}
366 return {'value': value, 'domain': domain}
368 def onchange_address(self, cr, uid, ids, use_parent_address, parent_id, context=None):
369 def value_or_id(val):
370 """ return val or val.id if val is a browse record """
371 return val if isinstance(val, (bool, int, long, float, basestring)) else val.id
375 partner = self.browse(cr, uid, ids[0], context=context)
376 if partner.parent_id and partner.parent_id.id != parent_id:
377 result['warning'] = {'title': _('Warning'),
378 'message': _('Changing the company of a contact should only be done if it '
379 'was never correctly set. If an existing contact starts working for a new '
380 'company then a new contact should be created under that new '
381 'company. You can use the "Discard" button to abandon this change.')}
382 parent = self.browse(cr, uid, parent_id, context=context)
383 address_fields = self._address_fields(cr, uid, context=context)
384 result['value'] = dict((key, value_or_id(parent[key])) for key in address_fields)
386 result['value'] = {'use_parent_address': False}
389 def onchange_state(self, cr, uid, ids, state_id, context=None):
391 country_id = self.pool['res.country.state'].browse(cr, uid, state_id, context).country_id.id
392 return {'value':{'country_id':country_id}}
395 def _check_ean_key(self, cr, uid, ids, context=None):
396 for partner_o in self.pool['res.partner'].read(cr, uid, ids, ['ean13',]):
397 thisean=partner_o['ean13']
398 if thisean and thisean!='':
406 sum+=3*int(thisean[i])
407 if math.ceil(sum/10.0)*10-sum!=int(thisean[12]):
411 # _constraints = [(_check_ean_key, 'Error: Invalid ean code', ['ean13'])]
413 def _update_fields_values(self, cr, uid, partner, fields, context=None):
414 """ Returns dict of write() values for synchronizing ``fields`` """
417 column = self._all_columns[field].column
418 if column._type == 'one2many':
419 raise AssertionError('One2Many fields cannot be synchronized as part of `commercial_fields` or `address fields`')
420 if column._type == 'many2one':
421 values[field] = partner[field].id if partner[field] else False
422 elif column._type == 'many2many':
423 values[field] = [(6,0,[r.id for r in partner[field] or []])]
425 values[field] = partner[field]
428 def _address_fields(self, cr, uid, context=None):
429 """ Returns the list of address fields that are synced from the parent
430 when the `use_parent_address` flag is set. """
431 return list(ADDRESS_FIELDS)
433 def update_address(self, cr, uid, ids, vals, context=None):
434 address_fields = self._address_fields(cr, uid, context=context)
435 addr_vals = dict((key, vals[key]) for key in address_fields if key in vals)
437 return super(res_partner, self).write(cr, uid, ids, addr_vals, context)
439 def _commercial_fields(self, cr, uid, context=None):
440 """ Returns the list of fields that are managed by the commercial entity
441 to which a partner belongs. These fields are meant to be hidden on
442 partners that aren't `commercial entities` themselves, and will be
443 delegated to the parent `commercial entity`. The list is meant to be
444 extended by inheriting classes. """
447 def _commercial_sync_from_company(self, cr, uid, partner, context=None):
448 """ Handle sync of commercial fields when a new parent commercial entity is set,
449 as if they were related fields """
450 if partner.commercial_partner_id != partner:
451 commercial_fields = self._commercial_fields(cr, uid, context=context)
452 sync_vals = self._update_fields_values(cr, uid, partner.commercial_partner_id,
453 commercial_fields, context=context)
454 partner.write(sync_vals)
456 def _commercial_sync_to_children(self, cr, uid, partner, context=None):
457 """ Handle sync of commercial fields to descendants """
458 commercial_fields = self._commercial_fields(cr, uid, context=context)
459 sync_vals = self._update_fields_values(cr, uid, partner.commercial_partner_id,
460 commercial_fields, context=context)
461 sync_children = [c for c in partner.child_ids if not c.is_company]
462 for child in sync_children:
463 self._commercial_sync_to_children(cr, uid, child, context=context)
464 return self.write(cr, uid, [c.id for c in sync_children], sync_vals, context=context)
466 def _fields_sync(self, cr, uid, partner, update_values, context=None):
467 """ Sync commercial fields and address fields from company and to children after create/update,
468 just as if those were all modeled as fields.related to the parent """
469 # 1. From UPSTREAM: sync from parent
470 if update_values.get('parent_id') or update_values.get('use_parent_address'):
471 # 1a. Commercial fields: sync if parent changed
472 if update_values.get('parent_id'):
473 self._commercial_sync_from_company(cr, uid, partner, context=context)
474 # 1b. Address fields: sync if parent or use_parent changed *and* both are now set
475 if partner.parent_id and partner.use_parent_address:
476 onchange_vals = self.onchange_address(cr, uid, [partner.id],
477 use_parent_address=partner.use_parent_address,
478 parent_id=partner.parent_id.id,
479 context=context).get('value', {})
480 partner.update_address(onchange_vals)
482 # 2. To DOWNSTREAM: sync children
483 if partner.child_ids:
484 # 2a. Commercial Fields: sync if commercial entity
485 if partner.commercial_partner_id == partner:
486 commercial_fields = self._commercial_fields(cr, uid,
488 if any(field in update_values for field in commercial_fields):
489 self._commercial_sync_to_children(cr, uid, partner,
491 # 2b. Address fields: sync if address changed
492 address_fields = self._address_fields(cr, uid, context=context)
493 if any(field in update_values for field in address_fields):
494 domain_children = [('parent_id', '=', partner.id), ('use_parent_address', '=', True)]
495 update_ids = self.search(cr, uid, domain_children, context=context)
496 self.update_address(cr, uid, update_ids, update_values, context=context)
498 def _handle_first_contact_creation(self, cr, uid, partner, context=None):
499 """ On creation of first contact for a company (or root) that has no address, assume contact address
500 was meant to be company address """
501 parent = partner.parent_id
502 address_fields = self._address_fields(cr, uid, context=context)
503 if parent and (parent.is_company or not parent.parent_id) and len(parent.child_ids) == 1 and \
504 any(partner[f] for f in address_fields) and not any(parent[f] for f in address_fields):
505 addr_vals = self._update_fields_values(cr, uid, partner, address_fields, context=context)
506 parent.update_address(addr_vals)
507 if not parent.is_company:
508 parent.write({'is_company': True})
510 def write(self, cr, uid, ids, vals, context=None):
511 if isinstance(ids, (int, long)):
513 #res.partner must only allow to set the company_id of a partner if it
514 #is the same as the company of all users that inherit from this partner
515 #(this is to allow the code from res_users to write to the partner!) or
516 #if setting the company_id to False (this is compatible with any user company)
517 if vals.get('company_id'):
518 for partner in self.browse(cr, uid, ids, context=context):
520 user_companies = set([user.company_id.id for user in partner.user_ids])
521 if len(user_companies) > 1 or vals['company_id'] not in user_companies:
522 raise osv.except_osv(_("Warning"),_("You can not change the company as the partner/user has multiple user linked with different companies."))
523 result = super(res_partner,self).write(cr, uid, ids, vals, context=context)
524 for partner in self.browse(cr, uid, ids, context=context):
525 self._fields_sync(cr, uid, partner, vals, context)
528 def create(self, cr, uid, vals, context=None):
529 new_id = super(res_partner, self).create(cr, uid, vals, context=context)
530 partner = self.browse(cr, uid, new_id, context=context)
531 self._fields_sync(cr, uid, partner, vals, context)
532 self._handle_first_contact_creation(cr, uid, partner, context)
535 def open_commercial_entity(self, cr, uid, ids, context=None):
536 """ Utility method used to add an "Open Company" button in partner views """
537 partner = self.browse(cr, uid, ids[0], context=context)
538 return {'type': 'ir.actions.act_window',
539 'res_model': 'res.partner',
541 'res_id': partner.commercial_partner_id.id,
543 'flags': {'form': {'action_buttons': True}}}
545 def open_parent(self, cr, uid, ids, context=None):
546 """ Utility method used to add an "Open Parent" button in partner views """
547 partner = self.browse(cr, uid, ids[0], context=context)
548 return {'type': 'ir.actions.act_window',
549 'res_model': 'res.partner',
551 'res_id': partner.parent_id.id,
553 'flags': {'form': {'action_buttons': True}}}
555 def name_get(self, cr, uid, ids, context=None):
558 if isinstance(ids, (int, long)):
561 for record in self.browse(cr, uid, ids, context=context):
563 if record.parent_id and not record.is_company:
564 name = "%s, %s" % (record.parent_id.name, name)
565 if context.get('show_address_only'):
566 name = self._display_address(cr, uid, record, without_company=True, context=context)
567 if context.get('show_address'):
568 name = name + "\n" + self._display_address(cr, uid, record, without_company=True, context=context)
569 name = name.replace('\n\n','\n')
570 name = name.replace('\n\n','\n')
571 if context.get('show_email') and record.email:
572 name = "%s <%s>" % (name, record.email)
573 res.append((record.id, name))
576 def _parse_partner_name(self, text, context=None):
577 """ Supported syntax:
578 - 'Raoul <raoul@grosbedon.fr>': will find name and email address
579 - otherwise: default, everything is set as the name """
580 emails = tools.email_split(text.replace(' ',','))
583 name = text[:text.index(email)].replace('"', '').replace('<', '').strip()
585 name, email = text, ''
588 def name_create(self, cr, uid, name, context=None):
589 """ Override of orm's name_create method for partners. The purpose is
590 to handle some basic formats to create partners using the
592 If only an email address is received and that the regex cannot find
593 a name, the name will have the email value.
594 If 'force_email' key in context: must find the email address. """
597 name, email = self._parse_partner_name(name, context=context)
598 if context.get('force_email') and not email:
599 raise osv.except_osv(_('Warning'), _("Couldn't create contact without email address!"))
600 if not name and email:
602 rec_id = self.create(cr, uid, {self._rec_name: name or email, 'email': email or False}, context=context)
603 return self.name_get(cr, uid, [rec_id], context)[0]
605 def _search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False, access_rights_uid=None):
606 """ Override search() to always show inactive children when searching via ``child_of`` operator. The ORM will
607 always call search() with a simple domain of the form [('parent_id', 'in', [ids])]. """
608 # a special ``domain`` is set on the ``child_ids`` o2m to bypass this logic, as it uses similar domain expressions
609 if len(args) == 1 and len(args[0]) == 3 and args[0][:2] == ('parent_id','in') \
610 and args[0][2] != [False]:
611 context = dict(context or {}, active_test=False)
612 return super(res_partner, self)._search(cr, user, args, offset=offset, limit=limit, order=order, context=context,
613 count=count, access_rights_uid=access_rights_uid)
615 def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=100):
618 if name and operator in ('=', 'ilike', '=ilike', 'like', '=like'):
620 self.check_access_rights(cr, uid, 'read')
621 where_query = self._where_calc(cr, uid, args, context=context)
622 self._apply_ir_rules(cr, uid, where_query, 'read', context=context)
623 from_clause, where_clause, where_clause_params = where_query.get_sql()
624 where_str = where_clause and (" WHERE %s AND " % where_clause) or ' WHERE '
626 # search on the name of the contacts and of its company
628 if operator in ('ilike', 'like'):
629 search_name = '%%%s%%' % name
630 if operator in ('=ilike', '=like'):
631 operator = operator[1:]
633 unaccent = get_unaccent_wrapper(cr)
637 {where} ({email} {operator} {percent}
638 OR {display_name} {operator} {percent})
639 ORDER BY {display_name}
640 """.format(where=where_str, operator=operator,
641 email=unaccent('email'),
642 display_name=unaccent('display_name'),
643 percent=unaccent('%s'))
645 where_clause_params += [search_name, search_name]
648 where_clause_params.append(limit)
649 cr.execute(query, where_clause_params)
650 ids = map(lambda x: x[0], cr.fetchall())
653 return self.name_get(cr, uid, ids, context)
656 return super(res_partner,self).name_search(cr, uid, name, args, operator=operator, context=context, limit=limit)
658 def find_or_create(self, cr, uid, email, context=None):
659 """ Find a partner with the given ``email`` or use :py:method:`~.name_create`
662 :param str email: email-like string, which should contain at least one email,
663 e.g. ``"Raoul Grosbedon <r.g@grosbedon.fr>"``"""
664 assert email, 'an email is required for find_or_create to work'
665 emails = tools.email_split(email)
668 ids = self.search(cr, uid, [('email','ilike',email)], context=context)
670 return self.name_create(cr, uid, email, context=context)[0]
673 def _email_send(self, cr, uid, ids, email_from, subject, body, on_error=None):
674 partners = self.browse(cr, uid, ids)
675 for partner in partners:
677 tools.email_send(email_from, [partner.email], subject, body, on_error)
680 def email_send(self, cr, uid, ids, email_from, subject, body, on_error=''):
682 self.pool['ir.cron'].create(cr, uid, {
683 'name': 'Send Partner Emails',
685 'model': 'res.partner',
686 'function': '_email_send',
687 'args': repr([ids[:16], email_from, subject, body, on_error])
692 def address_get(self, cr, uid, ids, adr_pref=None, context=None):
693 """ Find contacts/addresses of the right type(s) by doing a depth-first-search
694 through descendants within company boundaries (stop at entities flagged ``is_company``)
695 then continuing the search at the ancestors that are within the same company boundaries.
696 Defaults to partners of type ``'default'`` when the exact type is not found, or to the
697 provided partner itself if no type ``'default'`` is found either. """
698 adr_pref = set(adr_pref or [])
699 if 'default' not in adr_pref:
700 adr_pref.add('default')
703 for partner in self.browse(cr, uid, filter(None, ids), context=context):
704 current_partner = partner
705 while current_partner:
706 to_scan = [current_partner]
707 # Scan descendants, DFS
709 record = to_scan.pop(0)
711 if record.type in adr_pref and not result.get(record.type):
712 result[record.type] = record.id
713 if len(result) == len(adr_pref):
715 to_scan = [c for c in record.child_ids
717 if not c.is_company] + to_scan
719 # Continue scanning at ancestor if current_partner is not a commercial entity
720 if current_partner.is_company or not current_partner.parent_id:
722 current_partner = current_partner.parent_id
724 # default to type 'default' or the partner itself
725 default = result.get('default', partner.id)
726 for adr_type in adr_pref:
727 result[adr_type] = result.get(adr_type) or default
730 def view_header_get(self, cr, uid, view_id, view_type, context):
731 res = super(res_partner, self).view_header_get(cr, uid, view_id, view_type, context)
733 if not context.get('category_id', False):
735 return _('Partners: ')+self.pool['res.partner.category'].browse(cr, uid, context['category_id'], context).name
737 def main_partner(self, cr, uid):
738 ''' Return the id of the main partner
740 model_data = self.pool['ir.model.data']
741 return model_data.browse(cr, uid,
742 model_data.search(cr, uid, [('module','=','base'),
743 ('name','=','main_partner')])[0],
746 def _display_address(self, cr, uid, address, without_company=False, context=None):
749 The purpose of this function is to build and return an address formatted accordingly to the
750 standards of the country where it belongs.
752 :param address: browse record of the res.partner to format
753 :returns: the address formatted in a display that fit its country habits (or the default ones
754 if not country is specified)
758 # get the information that will be injected into the display format
759 # get the address format
760 address_format = address.country_id and address.country_id.address_format or \
761 "%(street)s\n%(street2)s\n%(city)s %(state_code)s %(zip)s\n%(country_name)s"
763 'state_code': address.state_id and address.state_id.code or '',
764 'state_name': address.state_id and address.state_id.name or '',
765 'country_code': address.country_id and address.country_id.code or '',
766 'country_name': address.country_id and address.country_id.name or '',
767 'company_name': address.parent_id and address.parent_id.name or '',
769 for field in self._address_fields(cr, uid, context=context):
770 args[field] = getattr(address, field) or ''
772 args['company_name'] = ''
773 elif address.parent_id:
774 address_format = '%(company_name)s\n' + address_format
775 return address_format % args
777 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: