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 _clean_website(self, website):
 528         (scheme, netloc, path, params, query, fragment) = urlparse.urlparse(website)
 529         if not scheme:
 530             if not netloc:
 531                 netloc, path = path, ''
 532             website = urlparse.urlunparse(('http', netloc, path, params, query, fragment))
 533         return website
 534
 535     @api.multi
 536     def write(self, vals):
 537         # res.partner must only allow to set the company_id of a partner if it
 538         # is the same as the company of all users that inherit from this partner
 539         # (this is to allow the code from res_users to write to the partner!) or
 540         # if setting the company_id to False (this is compatible with any user
 541         # company)
 542         if vals.get('website'):
 543             vals['website'] = self._clean_website(vals['website'])
 544         if vals.get('company_id'):
 545             company = self.env['res.company'].browse(vals['company_id'])
 546             for partner in self:
 547                 if partner.user_ids:
 548                     companies = set(user.company_id for user in partner.user_ids)
 549                     if len(companies) > 1 or company not in companies:
 550                         raise osv.except_osv(_("Warning"),_("You can not change the company as the partner/user has multiple user linked with different companies."))
 551
 552         result = super(res_partner, self).write(vals)
 553         for partner in self:
 554             self._fields_sync(partner, vals)
 555         return result
 556
 557     @api.model
 558     def create(self, vals):
 559         if vals.get('website'):
 560             vals['website'] = self._clean_website(vals['website'])
 561         partner = super(res_partner, self).create(vals)
 562         self._fields_sync(partner, vals)
 563         self._handle_first_contact_creation(partner)
 564         return partner
 565
 566     def open_commercial_entity(self, cr, uid, ids, context=None):
 567         """ Utility method used to add an "Open Company" 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.commercial_partner_id.id,
 573                 'target': 'new',
 574                 'flags': {'form': {'action_buttons': True}}}
 575
 576     def open_parent(self, cr, uid, ids, context=None):
 577         """ Utility method used to add an "Open Parent" button in partner views """
 578         partner = self.browse(cr, uid, ids[0], context=context)
 579         return {'type': 'ir.actions.act_window',
 580                 'res_model': 'res.partner',
 581                 'view_mode': 'form',
 582                 'res_id': partner.parent_id.id,
 583                 'target': 'new',
 584                 'flags': {'form': {'action_buttons': True}}}
 585
 586     def name_get(self, cr, uid, ids, context=None):
 587         if context is None:
 588             context = {}
 589         if isinstance(ids, (int, long)):
 590             ids = [ids]
 591         res = []
 592         for record in self.browse(cr, uid, ids, context=context):
 593             name = record.name
 594             if record.parent_id and not record.is_company:
 595                 name = "%s, %s" % (record.parent_name, name)
 596             if context.get('show_address_only'):
 597                 name = self._display_address(cr, uid, record, without_company=True, context=context)
 598             if context.get('show_address'):
 599                 name = name + "\n" + self._display_address(cr, uid, record, without_company=True, context=context)
 600             name = name.replace('\n\n','\n')
 601             name = name.replace('\n\n','\n')
 602             if context.get('show_email') and record.email:
 603                 name = "%s <%s>" % (name, record.email)
 604             res.append((record.id, name))
 605         return res
 606
 607     def _parse_partner_name(self, text, context=None):
 608         """ Supported syntax:
 609             - 'Raoul <raoul@grosbedon.fr>': will find name and email address
 610             - otherwise: default, everything is set as the name """
 611         emails = tools.email_split(text.replace(' ',','))
 612         if emails:
 613             email = emails[0]
 614             name = text[:text.index(email)].replace('"', '').replace('<', '').strip()
 615         else:
 616             name, email = text, ''
 617         return name, email
 618
 619     def name_create(self, cr, uid, name, context=None):
 620         """ Override of orm's name_create method for partners. The purpose is
 621             to handle some basic formats to create partners using the
 622             name_create.
 623             If only an email address is received and that the regex cannot find
 624             a name, the name will have the email value.
 625             If 'force_email' key in context: must find the email address. """
 626         if context is None:
 627             context = {}
 628         name, email = self._parse_partner_name(name, context=context)
 629         if context.get('force_email') and not email:
 630             raise osv.except_osv(_('Warning'), _("Couldn't create contact without email address!"))
 631         if not name and email:
 632             name = email
 633         rec_id = self.create(cr, uid, {self._rec_name: name or email, 'email': email or False}, context=context)
 634         return self.name_get(cr, uid, [rec_id], context)[0]
 635
 636     def _search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False, access_rights_uid=None):
 637         """ Override search() to always show inactive children when searching via ``child_of`` operator. The ORM will
 638         always call search() with a simple domain of the form [('parent_id', 'in', [ids])]. """
 639         # a special ``domain`` is set on the ``child_ids`` o2m to bypass this logic, as it uses similar domain expressions
 640         if len(args) == 1 and len(args[0]) == 3 and args[0][:2] == ('parent_id','in') \
 641                 and args[0][2] != [False]:
 642             context = dict(context or {}, active_test=False)
 643         return super(res_partner, self)._search(cr, user, args, offset=offset, limit=limit, order=order, context=context,
 644                                                 count=count, access_rights_uid=access_rights_uid)
 645
 646     def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=100):
 647         if not args:
 648             args = []
 649         if name and operator in ('=', 'ilike', '=ilike', 'like', '=like'):
 650
 651             self.check_access_rights(cr, uid, 'read')
 652             where_query = self._where_calc(cr, uid, args, context=context)
 653             self._apply_ir_rules(cr, uid, where_query, 'read', context=context)
 654             from_clause, where_clause, where_clause_params = where_query.get_sql()
 655             where_str = where_clause and (" WHERE %s AND " % where_clause) or ' WHERE '
 656
 657             # search on the name of the contacts and of its company
 658             search_name = name
 659             if operator in ('ilike', 'like'):
 660                 search_name = '%%%s%%' % name
 661             if operator in ('=ilike', '=like'):
 662                 operator = operator[1:]
 663
 664             unaccent = get_unaccent_wrapper(cr)
 665
 666             query = """SELECT id
 667                          FROM res_partner
 668                       {where} ({email} {operator} {percent}
 669                            OR {display_name} {operator} {percent})
 670                      ORDER BY {display_name}
 671                     """.format(where=where_str, operator=operator,
 672                                email=unaccent('email'),
 673                                display_name=unaccent('display_name'),
 674                                percent=unaccent('%s'))
 675
 676             where_clause_params += [search_name, search_name]
 677             if limit:
 678                 query += ' limit %s'
 679                 where_clause_params.append(limit)
 680             cr.execute(query, where_clause_params)
 681             ids = map(lambda x: x[0], cr.fetchall())
 682
 683             if ids:
 684                 return self.name_get(cr, uid, ids, context)
 685             else:
 686                 return []
 687         return super(res_partner,self).name_search(cr, uid, name, args, operator=operator, context=context, limit=limit)
 688
 689     def find_or_create(self, cr, uid, email, context=None):
 690         """ Find a partner with the given ``email`` or use :py:method:`~.name_create`
 691             to create one
 692
 693             :param str email: email-like string, which should contain at least one email,
 694                 e.g. ``"Raoul Grosbedon <r.g@grosbedon.fr>"``"""
 695         assert email, 'an email is required for find_or_create to work'
 696         emails = tools.email_split(email)
 697         if emails:
 698             email = emails[0]
 699         ids = self.search(cr, uid, [('email','ilike',email)], context=context)
 700         if not ids:
 701             return self.name_create(cr, uid, email, context=context)[0]
 702         return ids[0]
 703
 704     def _email_send(self, cr, uid, ids, email_from, subject, body, on_error=None):
 705         partners = self.browse(cr, uid, ids)
 706         for partner in partners:
 707             if partner.email:
 708                 tools.email_send(email_from, [partner.email], subject, body, on_error)
 709         return True
 710
 711     def email_send(self, cr, uid, ids, email_from, subject, body, on_error=''):
 712         while len(ids):
 713             self.pool['ir.cron'].create(cr, uid, {
 714                 'name': 'Send Partner Emails',
 715                 'user_id': uid,
 716                 'model': 'res.partner',
 717                 'function': '_email_send',
 718                 'args': repr([ids[:16], email_from, subject, body, on_error])
 719             })
 720             ids = ids[16:]
 721         return True
 722
 723     def address_get(self, cr, uid, ids, adr_pref=None, context=None):
 724         """ Find contacts/addresses of the right type(s) by doing a depth-first-search
 725         through descendants within company boundaries (stop at entities flagged ``is_company``)
 726         then continuing the search at the ancestors that are within the same company boundaries.
 727         Defaults to partners of type ``'default'`` when the exact type is not found, or to the
 728         provided partner itself if no type ``'default'`` is found either. """
 729         adr_pref = set(adr_pref or [])
 730         if 'default' not in adr_pref:
 731             adr_pref.add('default')
 732         result = {}
 733         visited = set()
 734         for partner in self.browse(cr, uid, filter(None, ids), context=context):
 735             current_partner = partner
 736             while current_partner:
 737                 to_scan = [current_partner]
 738                 # Scan descendants, DFS
 739                 while to_scan:
 740                     record = to_scan.pop(0)
 741                     visited.add(record)
 742                     if record.type in adr_pref and not result.get(record.type):
 743                         result[record.type] = record.id
 744                     if len(result) == len(adr_pref):
 745                         return result
 746                     to_scan = [c for c in record.child_ids
 747                                  if c not in visited
 748                                  if not c.is_company] + to_scan
 749
 750                 # Continue scanning at ancestor if current_partner is not a commercial entity
 751                 if current_partner.is_company or not current_partner.parent_id:
 752                     break
 753                 current_partner = current_partner.parent_id
 754
 755         # default to type 'default' or the partner itself
 756         default = result.get('default', partner.id)
 757         for adr_type in adr_pref:
 758             result[adr_type] = result.get(adr_type) or default
 759         return result
 760
 761     def view_header_get(self, cr, uid, view_id, view_type, context):
 762         res = super(res_partner, self).view_header_get(cr, uid, view_id, view_type, context)
 763         if res: return res
 764         if not context.get('category_id', False):
 765             return False
 766         return _('Partners: ')+self.pool['res.partner.category'].browse(cr, uid, context['category_id'], context).name
 767
 768     @api.model
 769     @api.returns('self')
 770     def main_partner(self):
 771         ''' Return the main partner '''
 772         return self.env.ref('base.main_partner')
 773
 774     def _display_address(self, cr, uid, address, without_company=False, context=None):
 775
 776         '''
 777         The purpose of this function is to build and return an address formatted accordingly to the
 778         standards of the country where it belongs.
 779
 780         :param address: browse record of the res.partner to format
 781         :returns: the address formatted in a display that fit its country habits (or the default ones
 782             if not country is specified)
 783         :rtype: string
 784         '''
 785
 786         # get the information that will be injected into the display format
 787         # get the address format
 788         address_format = address.country_id.address_format or \
 789               "%(street)s\n%(street2)s\n%(city)s %(state_code)s %(zip)s\n%(country_name)s"
 790         args = {
 791             'state_code': address.state_id.code or '',
 792             'state_name': address.state_id.name or '',
 793             'country_code': address.country_id.code or '',
 794             'country_name': address.country_id.name or '',
 795             'company_name': address.parent_name or '',
 796         }
 797         for field in self._address_fields(cr, uid, context=context):
 798             args[field] = getattr(address, field) or ''
 799         if without_company:
 800             args['company_name'] = ''
 801         elif address.parent_id:
 802             address_format = '%(company_name)s\n' + address_format
 803         return address_format % args
 804
 805 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: