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         'barcode': fields.char('Barcode', oldname='ean13'),
 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 _update_fields_values(self, cr, uid, partner, fields, context=None):
 399         """ Returns dict of write() values for synchronizing ``fields`` """
 400         values = {}
 401         for fname in fields:
 402             field = self._fields[fname]
 403             if field.type == 'one2many':
 404                 raise AssertionError('One2Many fields cannot be synchronized as part of `commercial_fields` or `address fields`')
 405             if field.type == 'many2one':
 406                 values[fname] = partner[fname].id if partner[fname] else False
 407             elif field.type == 'many2many':
 408                 values[fname] = [(6,0,[r.id for r in partner[fname] or []])]
 409             else:
 410                 values[fname] = partner[fname]
 411         return values
 412
 413     def _address_fields(self, cr, uid, context=None):
 414         """ Returns the list of address fields that are synced from the parent
 415         when the `use_parent_address` flag is set. """
 416         return list(ADDRESS_FIELDS)
 417
 418     def update_address(self, cr, uid, ids, vals, context=None):
 419         address_fields = self._address_fields(cr, uid, context=context)
 420         addr_vals = dict((key, vals[key]) for key in address_fields if key in vals)
 421         if addr_vals:
 422             return super(res_partner, self).write(cr, uid, ids, addr_vals, context)
 423
 424     def _commercial_fields(self, cr, uid, context=None):
 425         """ Returns the list of fields that are managed by the commercial entity
 426         to which a partner belongs. These fields are meant to be hidden on
 427         partners that aren't `commercial entities` themselves, and will be
 428         delegated to the parent `commercial entity`. The list is meant to be
 429         extended by inheriting classes. """
 430         return ['vat']
 431
 432     def _commercial_sync_from_company(self, cr, uid, partner, context=None):
 433         """ Handle sync of commercial fields when a new parent commercial entity is set,
 434         as if they were related fields """
 435         commercial_partner = partner.commercial_partner_id
 436         if not commercial_partner:
 437             # On child partner creation of a parent partner,
 438             # the commercial_partner_id is not yet computed
 439             commercial_partner_id = self._commercial_partner_compute(
 440                 cr, uid, [partner.id], 'commercial_partner_id', [], context=context)[partner.id]
 441             commercial_partner = self.browse(cr, uid, commercial_partner_id, context=context)
 442         if commercial_partner != partner:
 443             commercial_fields = self._commercial_fields(cr, uid, context=context)
 444             sync_vals = self._update_fields_values(cr, uid, commercial_partner,
 445                                                    commercial_fields, context=context)
 446             partner.write(sync_vals)
 447
 448     def _commercial_sync_to_children(self, cr, uid, partner, context=None):
 449         """ Handle sync of commercial fields to descendants """
 450         commercial_fields = self._commercial_fields(cr, uid, context=context)
 451         commercial_partner = partner.commercial_partner_id
 452         if not commercial_partner:
 453             # On child partner creation of a parent partner,
 454             # the commercial_partner_id is not yet computed
 455             commercial_partner_id = self._commercial_partner_compute(
 456                 cr, uid, [partner.id], 'commercial_partner_id', [], context=context)[partner.id]
 457             commercial_partner = self.browse(cr, uid, commercial_partner_id, context=context)
 458         sync_vals = self._update_fields_values(cr, uid, commercial_partner,
 459                                                commercial_fields, context=context)
 460         sync_children = [c for c in partner.child_ids if not c.is_company]
 461         for child in sync_children:
 462             self._commercial_sync_to_children(cr, uid, child, context=context)
 463         return self.write(cr, uid, [c.id for c in sync_children], sync_vals, context=context)
 464
 465     def _fields_sync(self, cr, uid, partner, update_values, context=None):
 466         """ Sync commercial fields and address fields from company and to children after create/update,
 467         just as if those were all modeled as fields.related to the parent """
 468         # 1. From UPSTREAM: sync from parent
 469         if update_values.get('parent_id') or update_values.get('use_parent_address'):
 470             # 1a. Commercial fields: sync if parent changed
 471             if update_values.get('parent_id'):
 472                 self._commercial_sync_from_company(cr, uid, partner, context=context)
 473             # 1b. Address fields: sync if parent or use_parent changed *and* both are now set
 474             if partner.parent_id and partner.use_parent_address:
 475                 onchange_vals = self.onchange_address(cr, uid, [partner.id],
 476                                                       use_parent_address=partner.use_parent_address,
 477                                                       parent_id=partner.parent_id.id,
 478                                                       context=context).get('value', {})
 479                 partner.update_address(onchange_vals)
 480
 481         # 2. To DOWNSTREAM: sync children
 482         if partner.child_ids:
 483             # 2a. Commercial Fields: sync if commercial entity
 484             if partner.commercial_partner_id == partner:
 485                 commercial_fields = self._commercial_fields(cr, uid,
 486                                                             context=context)
 487                 if any(field in update_values for field in commercial_fields):
 488                     self._commercial_sync_to_children(cr, uid, partner,
 489                                                       context=context)
 490             # 2b. Address fields: sync if address changed
 491             address_fields = self._address_fields(cr, uid, context=context)
 492             if any(field in update_values for field in address_fields):
 493                 domain_children = [('parent_id', '=', partner.id), ('use_parent_address', '=', True)]
 494                 update_ids = self.search(cr, uid, domain_children, context=context)
 495                 self.update_address(cr, uid, update_ids, update_values, context=context)
 496
 497     def _handle_first_contact_creation(self, cr, uid, partner, context=None):
 498         """ On creation of first contact for a company (or root) that has no address, assume contact address
 499         was meant to be company address """
 500         parent = partner.parent_id
 501         address_fields = self._address_fields(cr, uid, context=context)
 502         if parent and (parent.is_company or not parent.parent_id) and len(parent.child_ids) == 1 and \
 503             any(partner[f] for f in address_fields) and not any(parent[f] for f in address_fields):
 504             addr_vals = self._update_fields_values(cr, uid, partner, address_fields, context=context)
 505             parent.update_address(addr_vals)
 506             if not parent.is_company:
 507                 parent.write({'is_company': True})
 508
 509     def unlink(self, cr, uid, ids, context=None):
 510         orphan_contact_ids = self.search(cr, uid,
 511             [('parent_id', 'in', ids), ('id', 'not in', ids), ('use_parent_address', '=', True)], context=context)
 512         if orphan_contact_ids:
 513             # no longer have a parent address
 514             self.write(cr, uid, orphan_contact_ids, {'use_parent_address': False}, context=context)
 515         return super(res_partner, self).unlink(cr, uid, ids, context=context)
 516
 517     def _clean_website(self, website):
 518         (scheme, netloc, path, params, query, fragment) = urlparse.urlparse(website)
 519         if not scheme:
 520             if not netloc:
 521                 netloc, path = path, ''
 522             website = urlparse.urlunparse(('http', netloc, path, params, query, fragment))
 523         return website
 524
 525     @api.multi
 526     def write(self, vals):
 527         # res.partner must only allow to set the company_id of a partner if it
 528         # is the same as the company of all users that inherit from this partner
 529         # (this is to allow the code from res_users to write to the partner!) or
 530         # if setting the company_id to False (this is compatible with any user
 531         # company)
 532         if vals.get('website'):
 533             vals['website'] = self._clean_website(vals['website'])
 534         if vals.get('company_id'):
 535             company = self.env['res.company'].browse(vals['company_id'])
 536             for partner in self:
 537                 if partner.user_ids:
 538                     companies = set(user.company_id for user in partner.user_ids)
 539                     if len(companies) > 1 or company not in companies:
 540                         raise osv.except_osv(_("Warning"),_("You can not change the company as the partner/user has multiple user linked with different companies."))
 541
 542         result = super(res_partner, self).write(vals)
 543         for partner in self:
 544             self._fields_sync(partner, vals)
 545         return result
 546
 547     @api.model
 548     def create(self, vals):
 549         if vals.get('website'):
 550             vals['website'] = self._clean_website(vals['website'])
 551         partner = super(res_partner, self).create(vals)
 552         self._fields_sync(partner, vals)
 553         self._handle_first_contact_creation(partner)
 554         return partner
 555
 556     def open_commercial_entity(self, cr, uid, ids, context=None):
 557         """ Utility method used to add an "Open Company" button in partner views """
 558         partner = self.browse(cr, uid, ids[0], context=context)
 559         return {'type': 'ir.actions.act_window',
 560                 'res_model': 'res.partner',
 561                 'view_mode': 'form',
 562                 'res_id': partner.commercial_partner_id.id,
 563                 'target': 'new',
 564                 'flags': {'form': {'action_buttons': True}}}
 565
 566     def open_parent(self, cr, uid, ids, context=None):
 567         """ Utility method used to add an "Open Parent" button in partner views """
 568         partner = self.browse(cr, uid, ids[0], context=context)
 569         return {'type': 'ir.actions.act_window',
 570                 'res_model': 'res.partner',
 571                 'view_mode': 'form',
 572                 'res_id': partner.parent_id.id,
 573                 'target': 'new',
 574                 'flags': {'form': {'action_buttons': True}}}
 575
 576     def name_get(self, cr, uid, ids, context=None):
 577         if context is None:
 578             context = {}
 579         if isinstance(ids, (int, long)):
 580             ids = [ids]
 581         res = []
 582         for record in self.browse(cr, uid, ids, context=context):
 583             name = record.name
 584             if record.parent_id and not record.is_company:
 585                 name = "%s, %s" % (record.parent_name, name)
 586             if context.get('show_address_only'):
 587                 name = self._display_address(cr, uid, record, without_company=True, context=context)
 588             if context.get('show_address'):
 589                 name = name + "\n" + self._display_address(cr, uid, record, without_company=True, context=context)
 590             name = name.replace('\n\n','\n')
 591             name = name.replace('\n\n','\n')
 592             if context.get('show_email') and record.email:
 593                 name = "%s <%s>" % (name, record.email)
 594             res.append((record.id, name))
 595         return res
 596
 597     def _parse_partner_name(self, text, context=None):
 598         """ Supported syntax:
 599             - 'Raoul <raoul@grosbedon.fr>': will find name and email address
 600             - otherwise: default, everything is set as the name """
 601         emails = tools.email_split(text.replace(' ',','))
 602         if emails:
 603             email = emails[0]
 604             name = text[:text.index(email)].replace('"', '').replace('<', '').strip()
 605         else:
 606             name, email = text, ''
 607         return name, email
 608
 609     def name_create(self, cr, uid, name, context=None):
 610         """ Override of orm's name_create method for partners. The purpose is
 611             to handle some basic formats to create partners using the
 612             name_create.
 613             If only an email address is received and that the regex cannot find
 614             a name, the name will have the email value.
 615             If 'force_email' key in context: must find the email address. """
 616         if context is None:
 617             context = {}
 618         name, email = self._parse_partner_name(name, context=context)
 619         if context.get('force_email') and not email:
 620             raise osv.except_osv(_('Warning'), _("Couldn't create contact without email address!"))
 621         if not name and email:
 622             name = email
 623         rec_id = self.create(cr, uid, {self._rec_name: name or email, 'email': email or False}, context=context)
 624         return self.name_get(cr, uid, [rec_id], context)[0]
 625
 626     def _search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False, access_rights_uid=None):
 627         """ Override search() to always show inactive children when searching via ``child_of`` operator. The ORM will
 628         always call search() with a simple domain of the form [('parent_id', 'in', [ids])]. """
 629         # a special ``domain`` is set on the ``child_ids`` o2m to bypass this logic, as it uses similar domain expressions
 630         if len(args) == 1 and len(args[0]) == 3 and args[0][:2] == ('parent_id','in') \
 631                 and args[0][2] != [False]:
 632             context = dict(context or {}, active_test=False)
 633         return super(res_partner, self)._search(cr, user, args, offset=offset, limit=limit, order=order, context=context,
 634                                                 count=count, access_rights_uid=access_rights_uid)
 635
 636     def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=100):
 637         if not args:
 638             args = []
 639         if name and operator in ('=', 'ilike', '=ilike', 'like', '=like'):
 640
 641             self.check_access_rights(cr, uid, 'read')
 642             where_query = self._where_calc(cr, uid, args, context=context)
 643             self._apply_ir_rules(cr, uid, where_query, 'read', context=context)
 644             from_clause, where_clause, where_clause_params = where_query.get_sql()
 645             where_str = where_clause and (" WHERE %s AND " % where_clause) or ' WHERE '
 646
 647             # search on the name of the contacts and of its company
 648             search_name = name
 649             if operator in ('ilike', 'like'):
 650                 search_name = '%%%s%%' % name
 651             if operator in ('=ilike', '=like'):
 652                 operator = operator[1:]
 653
 654             unaccent = get_unaccent_wrapper(cr)
 655
 656             query = """SELECT id
 657                          FROM res_partner
 658                       {where} ({email} {operator} {percent}
 659                            OR {display_name} {operator} {percent})
 660                      ORDER BY {display_name}
 661                     """.format(where=where_str, operator=operator,
 662                                email=unaccent('email'),
 663                                display_name=unaccent('display_name'),
 664                                percent=unaccent('%s'))
 665
 666             where_clause_params += [search_name, search_name]
 667             if limit:
 668                 query += ' limit %s'
 669                 where_clause_params.append(limit)
 670             cr.execute(query, where_clause_params)
 671             ids = map(lambda x: x[0], cr.fetchall())
 672
 673             if ids:
 674                 return self.name_get(cr, uid, ids, context)
 675             else:
 676                 return []
 677         return super(res_partner,self).name_search(cr, uid, name, args, operator=operator, context=context, limit=limit)
 678
 679     def find_or_create(self, cr, uid, email, context=None):
 680         """ Find a partner with the given ``email`` or use :py:method:`~.name_create`
 681             to create one
 682
 683             :param str email: email-like string, which should contain at least one email,
 684                 e.g. ``"Raoul Grosbedon <r.g@grosbedon.fr>"``"""
 685         assert email, 'an email is required for find_or_create to work'
 686         emails = tools.email_split(email)
 687         if emails:
 688             email = emails[0]
 689         ids = self.search(cr, uid, [('email','ilike',email)], context=context)
 690         if not ids:
 691             return self.name_create(cr, uid, email, context=context)[0]
 692         return ids[0]
 693
 694     def _email_send(self, cr, uid, ids, email_from, subject, body, on_error=None):
 695         partners = self.browse(cr, uid, ids)
 696         for partner in partners:
 697             if partner.email:
 698                 tools.email_send(email_from, [partner.email], subject, body, on_error)
 699         return True
 700
 701     def email_send(self, cr, uid, ids, email_from, subject, body, on_error=''):
 702         while len(ids):
 703             self.pool['ir.cron'].create(cr, uid, {
 704                 'name': 'Send Partner Emails',
 705                 'user_id': uid,
 706                 'model': 'res.partner',
 707                 'function': '_email_send',
 708                 'args': repr([ids[:16], email_from, subject, body, on_error])
 709             })
 710             ids = ids[16:]
 711         return True
 712
 713     def address_get(self, cr, uid, ids, adr_pref=None, context=None):
 714         """ Find contacts/addresses of the right type(s) by doing a depth-first-search
 715         through descendants within company boundaries (stop at entities flagged ``is_company``)
 716         then continuing the search at the ancestors that are within the same company boundaries.
 717         Defaults to partners of type ``'default'`` when the exact type is not found, or to the
 718         provided partner itself if no type ``'default'`` is found either. """
 719         adr_pref = set(adr_pref or [])
 720         if 'default' not in adr_pref:
 721             adr_pref.add('default')
 722         result = {}
 723         visited = set()
 724         for partner in self.browse(cr, uid, filter(None, ids), context=context):
 725             current_partner = partner
 726             while current_partner:
 727                 to_scan = [current_partner]
 728                 # Scan descendants, DFS
 729                 while to_scan:
 730                     record = to_scan.pop(0)
 731                     visited.add(record)
 732                     if record.type in adr_pref and not result.get(record.type):
 733                         result[record.type] = record.id
 734                     if len(result) == len(adr_pref):
 735                         return result
 736                     to_scan = [c for c in record.child_ids
 737                                  if c not in visited
 738                                  if not c.is_company] + to_scan
 739
 740                 # Continue scanning at ancestor if current_partner is not a commercial entity
 741                 if current_partner.is_company or not current_partner.parent_id:
 742                     break
 743                 current_partner = current_partner.parent_id
 744
 745         # default to type 'default' or the partner itself
 746         default = result.get('default', partner.id)
 747         for adr_type in adr_pref:
 748             result[adr_type] = result.get(adr_type) or default
 749         return result
 750
 751     def view_header_get(self, cr, uid, view_id, view_type, context):
 752         res = super(res_partner, self).view_header_get(cr, uid, view_id, view_type, context)
 753         if res: return res
 754         if not context.get('category_id', False):
 755             return False
 756         return _('Partners: ')+self.pool['res.partner.category'].browse(cr, uid, context['category_id'], context).name
 757
 758     @api.model
 759     @api.returns('self')
 760     def main_partner(self):
 761         ''' Return the main partner '''
 762         return self.env.ref('base.main_partner')
 763
 764     def _display_address(self, cr, uid, address, without_company=False, context=None):
 765
 766         '''
 767         The purpose of this function is to build and return an address formatted accordingly to the
 768         standards of the country where it belongs.
 769
 770         :param address: browse record of the res.partner to format
 771         :returns: the address formatted in a display that fit its country habits (or the default ones
 772             if not country is specified)
 773         :rtype: string
 774         '''
 775
 776         # get the information that will be injected into the display format
 777         # get the address format
 778         address_format = address.country_id.address_format or \
 779               "%(street)s\n%(street2)s\n%(city)s %(state_code)s %(zip)s\n%(country_name)s"
 780         args = {
 781             'state_code': address.state_id.code or '',
 782             'state_name': address.state_id.name or '',
 783             'country_code': address.country_id.code or '',
 784             'country_name': address.country_id.name or '',
 785             'company_name': address.parent_name or '',
 786         }
 787         for field in self._address_fields(cr, uid, context=context):
 788             args[field] = getattr(address, field) or ''
 789         if without_company:
 790             args['company_name'] = ''
 791         elif address.parent_id:
 792             address_format = '%(company_name)s\n' + address_format
 793         return address_format % args
 794
 795 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: