openerp/addons/base/res/res_partner.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
   6 #
   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.
  11 #
  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.
  16 #
  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/>.
  19 #
  20 ##############################################################################
  21
  22 import datetime
  23 from lxml import etree
  24 import math
  25 import pytz
  26 import urlparse
  27
  28 import openerp
  29 from openerp import tools, api
  30 from openerp.osv import osv, fields
  31 from openerp.osv.expression import get_unaccent_wrapper
  32 from openerp.tools.translate import _
  33
  34 ADDRESS_FORMAT_LAYOUTS = {
  35     '%(city)s %(state_code)s\n%(zip)s': """
  36         <div class="address_format">
  37             <field name="city" placeholder="City" style="width: 50%%"/>
  38             <field name="state_id" class="oe_no_button" placeholder="State" style="width: 47%%" options='{"no_open": true}'/>
  39             <br/>
  40             <field name="zip" placeholder="ZIP"/>
  41         </div>
  42     """,
  43     '%(zip)s %(city)s': """
  44         <div class="address_format">
  45             <field name="zip" placeholder="ZIP" style="width: 40%%"/>
  46             <field name="city" placeholder="City" style="width: 57%%"/>
  47             <br/>
  48             <field name="state_id" class="oe_no_button" placeholder="State" options='{"no_open": true}'/>
  49         </div>
  50     """,
  51     '%(city)s\n%(state_name)s\n%(zip)s': """
  52         <div class="address_format">
  53             <field name="city" placeholder="City"/>
  54             <field name="state_id" class="oe_no_button" placeholder="State" options='{"no_open": true}'/>
  55             <field name="zip" placeholder="ZIP"/>
  56         </div>
  57     """
  58 }
  59
  60
  61 class format_address(object):
  62     @api.model
  63     def fields_view_get_address(self, arch):
  64         fmt = self.env.user.company_id.country_id.address_format or ''
  65         for k, v in ADDRESS_FORMAT_LAYOUTS.items():
  66             if k in fmt:
  67                 doc = etree.fromstring(arch)
  68                 for node in doc.xpath("//div[@class='address_format']"):
  69                     tree = etree.fromstring(v)
  70                     node.getparent().replace(node, tree)
  71                 arch = etree.tostring(doc)
  72                 break
  73         return arch
  74
  75
  76 @api.model
  77 def _tz_get(self):
  78     # put POSIX 'Etc/*' entries at the end to avoid confusing users - see bug 1086728
  79     return [(tz,tz) for tz in sorted(pytz.all_timezones, key=lambda tz: tz if not tz.startswith('Etc/') else '_')]
  80
  81
  82 class res_partner_category(osv.Model):
  83
  84     def name_get(self, cr, uid, ids, context=None):
  85         """ Return the categories' display name, including their direct
  86             parent by default.
  87
  88             If ``context['partner_category_display']`` is ``'short'``, the short
  89             version of the category name (without the direct parent) is used.
  90             The default is the long version.
  91         """
  92         if not isinstance(ids, list):
  93             ids = [ids]
  94         if context is None:
  95             context = {}
  96
  97         if context.get('partner_category_display') == 'short':
  98             return super(res_partner_category, self).name_get(cr, uid, ids, context=context)
  99
 100         res = []
 101         for category in self.browse(cr, uid, ids, context=context):
 102             names = []
 103             current = category
 104             while current:
 105                 names.append(current.name)
 106                 current = current.parent_id
 107             res.append((category.id, ' / '.join(reversed(names))))
 108         return res
 109
 110     @api.model
 111     def name_search(self, name, args=None, operator='ilike', limit=100):
 112         args = args or []
 113         if name:
 114             # Be sure name_search is symetric to name_get
 115             name = name.split(' / ')[-1]
 116             args = [('name', operator, name)] + args
 117         categories = self.search(args, limit=limit)
 118         return categories.name_get()
 119
 120     @api.multi
 121     def _name_get_fnc(self, field_name, arg):
 122         return dict(self.name_get())
 123
 124     _description = 'Partner Tags'
 125     _name = 'res.partner.category'
 126     _columns = {
 127         'name': fields.char('Category Name', required=True, translate=True),
 128         'parent_id': fields.many2one('res.partner.category', 'Parent Category', select=True, ondelete='cascade'),
 129         'complete_name': fields.function(_name_get_fnc, type="char", string='Full Name'),
 130         'child_ids': fields.one2many('res.partner.category', 'parent_id', 'Child Categories'),
 131         'active': fields.boolean('Active', help="The active field allows you to hide the category without removing it."),
 132         'parent_left': fields.integer('Left parent', select=True),
 133         'parent_right': fields.integer('Right parent', select=True),
 134         'partner_ids': fields.many2many('res.partner', id1='category_id', id2='partner_id', string='Partners'),
 135     }
 136     _constraints = [
 137         (osv.osv._check_recursion, 'Error ! You can not create recursive categories.', ['parent_id'])
 138     ]
 139     _defaults = {
 140         'active': 1,
 141     }
 142     _parent_store = True
 143     _parent_order = 'name'
 144     _order = 'parent_left'
 145
 146
 147 class res_partner_title(osv.osv):
 148     _name = 'res.partner.title'
 149     _order = 'name'
 150     _columns = {
 151         'name': fields.char('Title', required=True, translate=True),
 152         'shortcut': fields.char('Abbreviation', translate=True),
 153         'domain': fields.selection([('partner', 'Partner'), ('contact', 'Contact')], 'Domain', required=True)
 154     }
 155     _defaults = {
 156         'domain': 'contact',
 157     }
 158
 159
 160 @api.model
 161 def _lang_get(self):
 162     languages = self.env['res.lang'].search([])
 163     return [(language.code, language.name) for language in languages]
 164
 165 # fields copy if 'use_parent_address' is checked
 166 ADDRESS_FIELDS = ('street', 'street2', 'zip', 'city', 'state_id', 'country_id')
 167
 168
 169 class res_partner(osv.Model, format_address):
 170     _description = 'Partner'
 171     _name = "res.partner"
 172
 173     def _address_display(self, cr, uid, ids, name, args, context=None):
 174         res = {}
 175         for partner in self.browse(cr, uid, ids, context=context):
 176             res[partner.id] = self._display_address(cr, uid, partner, context=context)
 177         return res
 178
 179     @api.multi
 180     def _get_tz_offset(self, name, args):
 181         return dict(
 182             (p.id, datetime.datetime.now(pytz.timezone(p.tz or 'GMT')).strftime('%z'))
 183             for p in self)
 184
 185     @api.multi
 186     def _get_image(self, name, args):
 187         return dict((p.id, tools.image_get_resized_images(p.image)) for p in self)
 188
 189     @api.one
 190     def _set_image(self, name, value, args):
 191         return self.write({'image': tools.image_resize_image_big(value)})
 192
 193     @api.multi
 194     def _has_image(self, name, args):
 195         return dict((p.id, bool(p.image)) for p in self)
 196
 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
 207         return result
 208
 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))
 215
 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)
 219
 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)
 223     }
 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)
 227     }
 228
 229     _order = "display_name"
 230     _columns = {
 231         'name': fields.char('Name', 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         'parent_name': fields.related('parent_id', 'name', type='char', readonly=True, string='Parent name'),
 237         'child_ids': fields.one2many('res.partner', 'parent_id', 'Contacts', domain=[('active','=',True)]), # force "active_test" domain to bypass _search() override
 238         'ref': fields.char('Internal Reference', select=1),
 239         'lang': fields.selection(_lang_get, 'Language',
 240             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."),
 241         'tz': fields.selection(_tz_get,  'Timezone', size=64,
 242             help="The partner's timezone, used to output proper date and time values inside printed reports. "
 243                  "It is important to set a value for this field. You should use the same timezone "
 244                  "that is otherwise used to pick and render date and time values: your computer's timezone."),
 245         'tz_offset': fields.function(_get_tz_offset, type='char', size=5, string='Timezone offset', invisible=True),
 246         'user_id': fields.many2one('res.users', 'Salesperson', help='The internal user that is in charge of communicating with this contact if any.'),
 247         'vat': fields.char('TIN', help="Tax Identification Number. Check the box if this contact is subjected to taxes. Used by the some of the legal statements."),
 248         'bank_ids': fields.one2many('res.partner.bank', 'partner_id', 'Banks'),
 249         'website': fields.char('Website', help="Website of Partner or Company"),
 250         'comment': fields.text('Notes'),
 251         'category_id': fields.many2many('res.partner.category', id1='partner_id', id2='category_id', string='Tags'),
 252         'credit_limit': fields.float(string='Credit Limit'),
 253         'ean13': fields.char('EAN13', size=13),
 254         'active': fields.boolean('Active'),
 255         'customer': fields.boolean('Is a Customer', help="Check this box if this contact is a customer."),
 256         'supplier': fields.boolean('Is a 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."),
 257         'employee': fields.boolean('Employee', help="Check this box if this contact is an Employee."),
 258         'function': fields.char('Job Position'),
 259         'type': fields.selection([('default', 'Default'), ('invoice', 'Invoice'),
 260                                    ('delivery', 'Shipping'), ('contact', 'Contact'),
 261                                    ('other', 'Other')], 'Address Type',
 262             help="Used to select automatically the right address according to the context in sales and purchases documents."),
 263         'street': fields.char('Street'),
 264         'street2': fields.char('Street2'),
 265         'zip': fields.char('Zip', size=24, change_default=True),
 266         'city': fields.char('City'),
 267         'state_id': fields.many2one("res.country.state", 'State', ondelete='restrict'),
 268         'country_id': fields.many2one('res.country', 'Country', ondelete='restrict'),
 269         'email': fields.char('Email'),
 270         'phone': fields.char('Phone'),
 271         'fax': fields.char('Fax'),
 272         'mobile': fields.char('Mobile'),
 273         'birthdate': fields.char('Birthdate'),
 274         'is_company': fields.boolean('Is a Company', help="Check if the contact is a company, otherwise it is a person"),
 275         'use_parent_address': fields.boolean('Use Company Address', help="Select this if you want to set company's address information  for this contact"),
 276         # image: all image fields are base64 encoded and PIL-supported
 277         'image': fields.binary("Image",
 278             help="This field holds the image used as avatar for this contact, limited to 1024x1024px"),
 279         'image_medium': fields.function(_get_image, fnct_inv=_set_image,
 280             string="Medium-sized image", type="binary", multi="_get_image",
 281             store={
 282                 'res.partner': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 283             },
 284             help="Medium-sized image of this contact. It is automatically "\
 285                  "resized as a 128x128px image, with aspect ratio preserved. "\
 286                  "Use this field in form views or some kanban views."),
 287         'image_small': fields.function(_get_image, fnct_inv=_set_image,
 288             string="Small-sized image", type="binary", multi="_get_image",
 289             store={
 290                 'res.partner': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 291             },
 292             help="Small-sized image of this contact. It is automatically "\
 293                  "resized as a 64x64px image, with aspect ratio preserved. "\
 294                  "Use this field anywhere a small image is required."),
 295         'has_image': fields.function(_has_image, string="Has image", type="boolean"),
 296         'company_id': fields.many2one('res.company', 'Company', select=1),
 297         'color': fields.integer('Color Index'),
 298         'user_ids': fields.one2many('res.users', 'partner_id', 'Users'),
 299         'contact_address': fields.function(_address_display,  type='char', string='Complete Address'),
 300
 301         # technical field used for managing commercial fields
 302         'commercial_partner_id': fields.function(_commercial_partner_id, type='many2one', relation='res.partner', string='Commercial Entity', store=_commercial_partner_store_triggers)
 303     }
 304
 305     @api.model
 306     def _default_category(self):
 307         category_id = self.env.context.get('category_id', False)
 308         return [category_id] if category_id else False
 309
 310     @api.model
 311     def _get_default_image(self, is_company, colorize=False):
 312         img_path = openerp.modules.get_module_resource(
 313             'base', 'static/src/img', 'company_image.png' if is_company else 'avatar.png')
 314         with open(img_path, 'rb') as f:
 315             image = f.read()
 316
 317         # colorize user avatars
 318         if not is_company:
 319             image = tools.image_colorize(image)
 320
 321         return tools.image_resize_image_big(image.encode('base64'))
 322
 323     def fields_view_get(self, cr, user, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
 324         if (not view_id) and (view_type=='form') and context and context.get('force_email', False):
 325             view_id = self.pool['ir.model.data'].get_object_reference(cr, user, 'base', 'view_partner_simple_form')[1]
 326         res = super(res_partner,self).fields_view_get(cr, user, view_id, view_type, context, toolbar=toolbar, submenu=submenu)
 327         if view_type == 'form':
 328             res['arch'] = self.fields_view_get_address(cr, user, res['arch'], context=context)
 329         return res
 330
 331     @api.model
 332     def _default_company(self):
 333         return self.env['res.company']._company_default_get('res.partner')
 334
 335     _defaults = {
 336         'active': True,
 337         'lang': api.model(lambda self: self.env.lang),
 338         'tz': api.model(lambda self: self.env.context.get('tz', False)),
 339         'customer': True,
 340         'category_id': _default_category,
 341         'company_id': _default_company,
 342         'color': 0,
 343         'is_company': False,
 344         'type': 'contact', # type 'default' is wildcard and thus inappropriate
 345         'use_parent_address': False,
 346         'image': False,
 347     }
 348
 349     _constraints = [
 350         (osv.osv._check_recursion, 'You cannot create recursive Partner hierarchies.', ['parent_id']),
 351     ]
 352
 353     @api.one
 354     def copy(self, default=None):
 355         default = dict(default or {})
 356         default['name'] = _('%s (copy)') % self.name
 357         return super(res_partner, self).copy(default)
 358
 359     @api.multi
 360     def onchange_type(self, is_company):
 361         value = {'title': False}
 362         if is_company:
 363             value['use_parent_address'] = False
 364             domain = {'title': [('domain', '=', 'partner')]}
 365         else:
 366             domain = {'title': [('domain', '=', 'contact')]}
 367         return {'value': value, 'domain': domain}
 368
 369     def onchange_address(self, cr, uid, ids, use_parent_address, parent_id, context=None):
 370         def value_or_id(val):
 371             """ return val or val.id if val is a browse record """
 372             return val if isinstance(val, (bool, int, long, float, basestring)) else val.id
 373         result = {}
 374         if parent_id:
 375             if ids:
 376                 partner = self.browse(cr, uid, ids[0], context=context)
 377                 if partner.parent_id and partner.parent_id.id != parent_id:
 378                     result['warning'] = {'title': _('Warning'),
 379                                          'message': _('Changing the company of a contact should only be done if it '
 380                                                       'was never correctly set. If an existing contact starts working for a new '
 381                                                       'company then a new contact should be created under that new '
 382                                                       'company. You can use the "Discard" button to abandon this change.')}
 383             if use_parent_address:
 384                 parent = self.browse(cr, uid, parent_id, context=context)
 385                 address_fields = self._address_fields(cr, uid, context=context)
 386                 result['value'] = dict((key, value_or_id(parent[key])) for key in address_fields)
 387         else:
 388             result['value'] = {'use_parent_address': False}
 389         return result
 390
 391     @api.multi
 392     def onchange_state(self, state_id):
 393         if state_id:
 394             state = self.env['res.country.state'].browse(state_id)
 395             return {'value': {'country_id': state.country_id.id}}
 396         return {}
 397
 398     def _check_ean_key(self, cr, uid, ids, context=None):
 399         for partner_o in self.pool['res.partner'].read(cr, uid, ids, ['ean13',]):
 400             thisean=partner_o['ean13']
 401             if thisean and thisean!='':
 402                 if len(thisean)!=13:
 403                     return False
 404                 sum=0
 405                 for i in range(12):
 406                     if not (i % 2):
 407                         sum+=int(thisean[i])
 408                     else:
 409                         sum+=3*int(thisean[i])
 410                 if math.ceil(sum/10.0)*10-sum!=int(thisean[12]):
 411                     return False
 412         return True
 413
 414 #   _constraints = [(_check_ean_key, 'Error: Invalid ean code', ['ean13'])]
 415
 416     def _update_fields_values(self, cr, uid, partner, fields, context=None):
 417         """ Returns dict of write() values for synchronizing ``fields`` """
 418         values = {}
 419         for fname in fields:
 420             field = self._fields[fname]
 421             if field.type == 'one2many':
 422                 raise AssertionError('One2Many fields cannot be synchronized as part of `commercial_fields` or `address fields`')
 423             if field.type == 'many2one':
 424                 values[fname] = partner[fname].id if partner[fname] else False
 425             elif field.type == 'many2many':
 426                 values[fname] = [(6,0,[r.id for r in partner[fname] or []])]
 427             else:
 428                 values[fname] = partner[fname]
 429         return values
 430
 431     def _address_fields(self, cr, uid, context=None):
 432         """ Returns the list of address fields that are synced from the parent
 433         when the `use_parent_address` flag is set. """
 434         return list(ADDRESS_FIELDS)
 435
 436     def update_address(self, cr, uid, ids, vals, context=None):
 437         address_fields = self._address_fields(cr, uid, context=context)
 438         addr_vals = dict((key, vals[key]) for key in address_fields if key in vals)
 439         if addr_vals:
 440             return super(res_partner, self).write(cr, uid, ids, addr_vals, context)
 441
 442     def _commercial_fields(self, cr, uid, context=None):
 443         """ Returns the list of fields that are managed by the commercial entity
 444         to which a partner belongs. These fields are meant to be hidden on
 445         partners that aren't `commercial entities` themselves, and will be
 446         delegated to the parent `commercial entity`. The list is meant to be
 447         extended by inheriting classes. """
 448         return ['vat']
 449
 450     def _commercial_sync_from_company(self, cr, uid, partner, context=None):
 451         """ Handle sync of commercial fields when a new parent commercial entity is set,
 452         as if they were related fields """
 453         commercial_partner = partner.commercial_partner_id
 454         if not commercial_partner:
 455             # On child partner creation of a parent partner,
 456             # the commercial_partner_id is not yet computed
 457             commercial_partner_id = self._commercial_partner_compute(
 458                 cr, uid, [partner.id], 'commercial_partner_id', [], context=context)[partner.id]
 459             commercial_partner = self.browse(cr, uid, commercial_partner_id, context=context)
 460         if commercial_partner != partner:
 461             commercial_fields = self._commercial_fields(cr, uid, context=context)
 462             sync_vals = self._update_fields_values(cr, uid, commercial_partner,
 463                                                    commercial_fields, context=context)
 464             partner.write(sync_vals)
 465
 466     def _commercial_sync_to_children(self, cr, uid, partner, context=None):
 467         """ Handle sync of commercial fields to descendants """
 468         commercial_fields = self._commercial_fields(cr, uid, context=context)
 469         commercial_partner = partner.commercial_partner_id
 470         if not commercial_partner:
 471             # On child partner creation of a parent partner,
 472             # the commercial_partner_id is not yet computed
 473             commercial_partner_id = self._commercial_partner_compute(
 474                 cr, uid, [partner.id], 'commercial_partner_id', [], context=context)[partner.id]
 475             commercial_partner = self.browse(cr, uid, commercial_partner_id, context=context)
 476         sync_vals = self._update_fields_values(cr, uid, commercial_partner,
 477                                                commercial_fields, context=context)
 478         sync_children = [c for c in partner.child_ids if not c.is_company]
 479         for child in sync_children:
 480             self._commercial_sync_to_children(cr, uid, child, context=context)
 481         return self.write(cr, uid, [c.id for c in sync_children], sync_vals, context=context)
 482
 483     def _fields_sync(self, cr, uid, partner, update_values, context=None):
 484         """ Sync commercial fields and address fields from company and to children after create/update,
 485         just as if those were all modeled as fields.related to the parent """
 486         # 1. From UPSTREAM: sync from parent
 487         if update_values.get('parent_id') or update_values.get('use_parent_address'):
 488             # 1a. Commercial fields: sync if parent changed
 489             if update_values.get('parent_id'):
 490                 self._commercial_sync_from_company(cr, uid, partner, context=context)
 491             # 1b. Address fields: sync if parent or use_parent changed *and* both are now set
 492             if partner.parent_id and partner.use_parent_address:
 493                 onchange_vals = self.onchange_address(cr, uid, [partner.id],
 494                                                       use_parent_address=partner.use_parent_address,
 495                                                       parent_id=partner.parent_id.id,
 496                                                       context=context).get('value', {})
 497                 partner.update_address(onchange_vals)
 498
 499         # 2. To DOWNSTREAM: sync children
 500         if partner.child_ids:
 501             # 2a. Commercial Fields: sync if commercial entity
 502             if partner.commercial_partner_id == partner:
 503                 commercial_fields = self._commercial_fields(cr, uid,
 504                                                             context=context)
 505                 if any(field in update_values for field in commercial_fields):
 506                     self._commercial_sync_to_children(cr, uid, partner,
 507                                                       context=context)
 508             # 2b. Address fields: sync if address changed
 509             address_fields = self._address_fields(cr, uid, context=context)
 510             if any(field in update_values for field in address_fields):
 511                 domain_children = [('parent_id', '=', partner.id), ('use_parent_address', '=', True)]
 512                 update_ids = self.search(cr, uid, domain_children, context=context)
 513                 self.update_address(cr, uid, update_ids, update_values, context=context)
 514
 515     def _handle_first_contact_creation(self, cr, uid, partner, context=None):
 516         """ On creation of first contact for a company (or root) that has no address, assume contact address
 517         was meant to be company address """
 518         parent = partner.parent_id
 519         address_fields = self._address_fields(cr, uid, context=context)
 520         if parent and (parent.is_company or not parent.parent_id) and len(parent.child_ids) == 1 and \
 521             any(partner[f] for f in address_fields) and not any(parent[f] for f in address_fields):
 522             addr_vals = self._update_fields_values(cr, uid, partner, address_fields, context=context)
 523             parent.update_address(addr_vals)
 524             if not parent.is_company:
 525                 parent.write({'is_company': True})
 526
 527     def unlink(self, cr, uid, ids, context=None):
 528         orphan_contact_ids = self.search(cr, uid,
 529             [('parent_id', 'in', ids), ('id', 'not in', ids), ('use_parent_address', '=', True)], context=context)
 530         if orphan_contact_ids:
 531             # no longer have a parent address
 532             self.write(cr, uid, orphan_contact_ids, {'use_parent_address': False}, context=context)
 533         return super(res_partner, self).unlink(cr, uid, ids, context=context)
 534
 535     def _clean_website(self, website):
 536         (scheme, netloc, path, params, query, fragment) = urlparse.urlparse(website)
 537         if not scheme:
 538             if not netloc:
 539                 netloc, path = path, ''
 540             website = urlparse.urlunparse(('http', netloc, path, params, query, fragment))
 541         return website
 542
 543     @api.multi
 544     def write(self, vals):
 545         # res.partner must only allow to set the company_id of a partner if it
 546         # is the same as the company of all users that inherit from this partner
 547         # (this is to allow the code from res_users to write to the partner!) or
 548         # if setting the company_id to False (this is compatible with any user
 549         # company)
 550         if vals.get('website'):
 551             vals['website'] = self._clean_website(vals['website'])
 552         if vals.get('company_id'):
 553             company = self.env['res.company'].browse(vals['company_id'])
 554             for partner in self:
 555                 if partner.user_ids:
 556                     companies = set(user.company_id for user in partner.user_ids)
 557                     if len(companies) > 1 or company not in companies:
 558                         raise osv.except_osv(_("Warning"),_("You can not change the company as the partner/user has multiple user linked with different companies."))
 559
 560         result = super(res_partner, self).write(vals)
 561         for partner in self:
 562             self._fields_sync(partner, vals)
 563         return result
 564
 565     @api.model
 566     def create(self, vals):
 567         if vals.get('website'):
 568             vals['website'] = self._clean_website(vals['website'])
 569         partner = super(res_partner, self).create(vals)
 570         self._fields_sync(partner, vals)
 571         self._handle_first_contact_creation(partner)
 572         return partner
 573
 574     def open_commercial_entity(self, cr, uid, ids, context=None):
 575         """ Utility method used to add an "Open Company" button in partner views """
 576         partner = self.browse(cr, uid, ids[0], context=context)
 577         return {'type': 'ir.actions.act_window',
 578                 'res_model': 'res.partner',
 579                 'view_mode': 'form',
 580                 'res_id': partner.commercial_partner_id.id,
 581                 'target': 'new',
 582                 'flags': {'form': {'action_buttons': True}}}
 583
 584     def open_parent(self, cr, uid, ids, context=None):
 585         """ Utility method used to add an "Open Parent" button in partner views """
 586         partner = self.browse(cr, uid, ids[0], context=context)
 587         return {'type': 'ir.actions.act_window',
 588                 'res_model': 'res.partner',
 589                 'view_mode': 'form',
 590                 'res_id': partner.parent_id.id,
 591                 'target': 'new',
 592                 'flags': {'form': {'action_buttons': True}}}
 593
 594     def name_get(self, cr, uid, ids, context=None):
 595         if context is None:
 596             context = {}
 597         if isinstance(ids, (int, long)):
 598             ids = [ids]
 599         res = []
 600         for record in self.browse(cr, uid, ids, context=context):
 601             name = record.name
 602             if record.parent_id and not record.is_company:
 603                 name = "%s, %s" % (record.parent_name, name)
 604             if context.get('show_address_only'):
 605                 name = self._display_address(cr, uid, record, without_company=True, context=context)
 606             if context.get('show_address'):
 607                 name = name + "\n" + self._display_address(cr, uid, record, without_company=True, context=context)
 608             name = name.replace('\n\n','\n')
 609             name = name.replace('\n\n','\n')
 610             if context.get('show_email') and record.email:
 611                 name = "%s <%s>" % (name, record.email)
 612             res.append((record.id, name))
 613         return res
 614
 615     def _parse_partner_name(self, text, context=None):
 616         """ Supported syntax:
 617             - 'Raoul <raoul@grosbedon.fr>': will find name and email address
 618             - otherwise: default, everything is set as the name """
 619         emails = tools.email_split(text.replace(' ',','))
 620         if emails:
 621             email = emails[0]
 622             name = text[:text.index(email)].replace('"', '').replace('<', '').strip()
 623         else:
 624             name, email = text, ''
 625         return name, email
 626
 627     def name_create(self, cr, uid, name, context=None):
 628         """ Override of orm's name_create method for partners. The purpose is
 629             to handle some basic formats to create partners using the
 630             name_create.
 631             If only an email address is received and that the regex cannot find
 632             a name, the name will have the email value.
 633             If 'force_email' key in context: must find the email address. """
 634         if context is None:
 635             context = {}
 636         name, email = self._parse_partner_name(name, context=context)
 637         if context.get('force_email') and not email:
 638             raise osv.except_osv(_('Warning'), _("Couldn't create contact without email address!"))
 639         if not name and email:
 640             name = email
 641         rec_id = self.create(cr, uid, {self._rec_name: name or email, 'email': email or False}, context=context)
 642         return self.name_get(cr, uid, [rec_id], context)[0]
 643
 644     def _search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False, access_rights_uid=None):
 645         """ Override search() to always show inactive children when searching via ``child_of`` operator. The ORM will
 646         always call search() with a simple domain of the form [('parent_id', 'in', [ids])]. """
 647         # a special ``domain`` is set on the ``child_ids`` o2m to bypass this logic, as it uses similar domain expressions
 648         if len(args) == 1 and len(args[0]) == 3 and args[0][:2] == ('parent_id','in') \
 649                 and args[0][2] != [False]:
 650             context = dict(context or {}, active_test=False)
 651         return super(res_partner, self)._search(cr, user, args, offset=offset, limit=limit, order=order, context=context,
 652                                                 count=count, access_rights_uid=access_rights_uid)
 653
 654     def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=100):
 655         if not args:
 656             args = []
 657         if name and operator in ('=', 'ilike', '=ilike', 'like', '=like'):
 658
 659             self.check_access_rights(cr, uid, 'read')
 660             where_query = self._where_calc(cr, uid, args, context=context)
 661             self._apply_ir_rules(cr, uid, where_query, 'read', context=context)
 662             from_clause, where_clause, where_clause_params = where_query.get_sql()
 663             where_str = where_clause and (" WHERE %s AND " % where_clause) or ' WHERE '
 664
 665             # search on the name of the contacts and of its company
 666             search_name = name
 667             if operator in ('ilike', 'like'):
 668                 search_name = '%%%s%%' % name
 669             if operator in ('=ilike', '=like'):
 670                 operator = operator[1:]
 671
 672             unaccent = get_unaccent_wrapper(cr)
 673
 674             query = """SELECT id
 675                          FROM res_partner
 676                       {where} ({email} {operator} {percent}
 677                            OR {display_name} {operator} {percent})
 678                      ORDER BY {display_name}
 679                     """.format(where=where_str, operator=operator,
 680                                email=unaccent('email'),
 681                                display_name=unaccent('display_name'),
 682                                percent=unaccent('%s'))
 683
 684             where_clause_params += [search_name, search_name]
 685             if limit:
 686                 query += ' limit %s'
 687                 where_clause_params.append(limit)
 688             cr.execute(query, where_clause_params)
 689             ids = map(lambda x: x[0], cr.fetchall())
 690
 691             if ids:
 692                 return self.name_get(cr, uid, ids, context)
 693             else:
 694                 return []
 695         return super(res_partner,self).name_search(cr, uid, name, args, operator=operator, context=context, limit=limit)
 696
 697     def find_or_create(self, cr, uid, email, context=None):
 698         """ Find a partner with the given ``email`` or use :py:method:`~.name_create`
 699             to create one
 700
 701             :param str email: email-like string, which should contain at least one email,
 702                 e.g. ``"Raoul Grosbedon <r.g@grosbedon.fr>"``"""
 703         assert email, 'an email is required for find_or_create to work'
 704         emails = tools.email_split(email)
 705         if emails:
 706             email = emails[0]
 707         ids = self.search(cr, uid, [('email','ilike',email)], context=context)
 708         if not ids:
 709             return self.name_create(cr, uid, email, context=context)[0]
 710         return ids[0]
 711
 712     def _email_send(self, cr, uid, ids, email_from, subject, body, on_error=None):
 713         partners = self.browse(cr, uid, ids)
 714         for partner in partners:
 715             if partner.email:
 716                 tools.email_send(email_from, [partner.email], subject, body, on_error)
 717         return True
 718
 719     def email_send(self, cr, uid, ids, email_from, subject, body, on_error=''):
 720         while len(ids):
 721             self.pool['ir.cron'].create(cr, uid, {
 722                 'name': 'Send Partner Emails',
 723                 'user_id': uid,
 724                 'model': 'res.partner',
 725                 'function': '_email_send',
 726                 'args': repr([ids[:16], email_from, subject, body, on_error])
 727             })
 728             ids = ids[16:]
 729         return True
 730
 731     def address_get(self, cr, uid, ids, adr_pref=None, context=None):
 732         """ Find contacts/addresses of the right type(s) by doing a depth-first-search
 733         through descendants within company boundaries (stop at entities flagged ``is_company``)
 734         then continuing the search at the ancestors that are within the same company boundaries.
 735         Defaults to partners of type ``'default'`` when the exact type is not found, or to the
 736         provided partner itself if no type ``'default'`` is found either. """
 737         adr_pref = set(adr_pref or [])
 738         if 'default' not in adr_pref:
 739             adr_pref.add('default')
 740         result = {}
 741         visited = set()
 742         for partner in self.browse(cr, uid, filter(None, ids), context=context):
 743             current_partner = partner
 744             while current_partner:
 745                 to_scan = [current_partner]
 746                 # Scan descendants, DFS
 747                 while to_scan:
 748                     record = to_scan.pop(0)
 749                     visited.add(record)
 750                     if record.type in adr_pref and not result.get(record.type):
 751                         result[record.type] = record.id
 752                     if len(result) == len(adr_pref):
 753                         return result
 754                     to_scan = [c for c in record.child_ids
 755                                  if c not in visited
 756                                  if not c.is_company] + to_scan
 757
 758                 # Continue scanning at ancestor if current_partner is not a commercial entity
 759                 if current_partner.is_company or not current_partner.parent_id:
 760                     break
 761                 current_partner = current_partner.parent_id
 762
 763         # default to type 'default' or the partner itself
 764         default = result.get('default', partner.id)
 765         for adr_type in adr_pref:
 766             result[adr_type] = result.get(adr_type) or default
 767         return result
 768
 769     def view_header_get(self, cr, uid, view_id, view_type, context):
 770         res = super(res_partner, self).view_header_get(cr, uid, view_id, view_type, context)
 771         if res: return res
 772         if not context.get('category_id', False):
 773             return False
 774         return _('Partners: ')+self.pool['res.partner.category'].browse(cr, uid, context['category_id'], context).name
 775
 776     @api.model
 777     @api.returns('self')
 778     def main_partner(self):
 779         ''' Return the main partner '''
 780         return self.env.ref('base.main_partner')
 781
 782     def _display_address(self, cr, uid, address, without_company=False, context=None):
 783
 784         '''
 785         The purpose of this function is to build and return an address formatted accordingly to the
 786         standards of the country where it belongs.
 787
 788         :param address: browse record of the res.partner to format
 789         :returns: the address formatted in a display that fit its country habits (or the default ones
 790             if not country is specified)
 791         :rtype: string
 792         '''
 793
 794         # get the information that will be injected into the display format
 795         # get the address format
 796         address_format = address.country_id.address_format or \
 797               "%(street)s\n%(street2)s\n%(city)s %(state_code)s %(zip)s\n%(country_name)s"
 798         args = {
 799             'state_code': address.state_id.code or '',
 800             'state_name': address.state_id.name or '',
 801             'country_code': address.country_id.code or '',
 802             'country_name': address.country_id.name or '',
 803             'company_name': address.parent_name or '',
 804         }
 805         for field in self._address_fields(cr, uid, context=context):
 806             args[field] = getattr(address, field) or ''
 807         if without_company:
 808             args['company_name'] = ''
 809         elif address.parent_id:
 810             address_format = '%(company_name)s\n' + address_format
 811         return address_format % args
 812
 813 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: