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         'child_ids': fields.one2many('res.partner', 'parent_id', 'Contacts', domain=[('active','=',True)]), # force "active_test" domain to bypass _search() override
 237         'ref': fields.char('Contact Reference', select=1),
 238         'lang': fields.selection(_lang_get, 'Language',
 239             help="If the selected language is loaded in the system, all documents related to this contact will be printed in this language. If not, it will be English."),
 240         'tz': fields.selection(_tz_get,  'Timezone', size=64,
 241             help="The partner's timezone, used to output proper date and time values inside printed reports. "
 242                  "It is important to set a value for this field. You should use the same timezone "
 243                  "that is otherwise used to pick and render date and time values: your computer's timezone."),
 244         'tz_offset': fields.function(_get_tz_offset, type='char', size=5, string='Timezone offset', invisible=True),
 245         'user_id': fields.many2one('res.users', 'Salesperson', help='The internal user that is in charge of communicating with this contact if any.'),
 246         'vat': fields.char('TIN', help="Tax Identification Number. Check the box if this contact is subjected to taxes. Used by the some of the legal statements."),
 247         'bank_ids': fields.one2many('res.partner.bank', 'partner_id', 'Banks'),
 248         'website': fields.char('Website', help="Website of Partner or Company"),
 249         'comment': fields.text('Notes'),
 250         'category_id': fields.many2many('res.partner.category', id1='partner_id', id2='category_id', string='Tags'),
 251         'credit_limit': fields.float(string='Credit Limit'),
 252         'ean13': fields.char('EAN13', size=13),
 253         'active': fields.boolean('Active'),
 254         'customer': fields.boolean('Customer', help="Check this box if this contact is a customer."),
 255         'supplier': fields.boolean('Supplier', help="Check this box if this contact is a supplier. If it's not checked, purchase people will not see it when encoding a purchase order."),
 256         'employee': fields.boolean('Employee', help="Check this box if this contact is an Employee."),
 257         'function': fields.char('Job Position'),
 258         'type': fields.selection([('default', 'Default'), ('invoice', 'Invoice'),
 259                                    ('delivery', 'Shipping'), ('contact', 'Contact'),
 260                                    ('other', 'Other')], 'Address Type',
 261             help="Used to select automatically the right address according to the context in sales and purchases documents."),
 262         'street': fields.char('Street'),
 263         'street2': fields.char('Street2'),
 264         'zip': fields.char('Zip', size=24, change_default=True),
 265         'city': fields.char('City'),
 266         'state_id': fields.many2one("res.country.state", 'State', ondelete='restrict'),
 267         'country_id': fields.many2one('res.country', 'Country', ondelete='restrict'),
 268         'email': fields.char('Email'),
 269         'phone': fields.char('Phone'),
 270         'fax': fields.char('Fax'),
 271         'mobile': fields.char('Mobile'),
 272         'birthdate': fields.char('Birthdate'),
 273         'is_company': fields.boolean('Is a Company', help="Check if the contact is a company, otherwise it is a person"),
 274         'use_parent_address': fields.boolean('Use Company Address', help="Select this if you want to set company's address information  for this contact"),
 275         # image: all image fields are base64 encoded and PIL-supported
 276         'image': fields.binary("Image",
 277             help="This field holds the image used as avatar for this contact, limited to 1024x1024px"),
 278         'image_medium': fields.function(_get_image, fnct_inv=_set_image,
 279             string="Medium-sized image", type="binary", multi="_get_image",
 280             store={
 281                 'res.partner': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 282             },
 283             help="Medium-sized image of this contact. It is automatically "\
 284                  "resized as a 128x128px image, with aspect ratio preserved. "\
 285                  "Use this field in form views or some kanban views."),
 286         'image_small': fields.function(_get_image, fnct_inv=_set_image,
 287             string="Small-sized image", type="binary", multi="_get_image",
 288             store={
 289                 'res.partner': (lambda self, cr, uid, ids, c={}: ids, ['image'], 10),
 290             },
 291             help="Small-sized image of this contact. It is automatically "\
 292                  "resized as a 64x64px image, with aspect ratio preserved. "\
 293                  "Use this field anywhere a small image is required."),
 294         'has_image': fields.function(_has_image, type="boolean"),
 295         'company_id': fields.many2one('res.company', 'Company', select=1),
 296         'color': fields.integer('Color Index'),
 297         'user_ids': fields.one2many('res.users', 'partner_id', 'Users'),
 298         'contact_address': fields.function(_address_display,  type='char', string='Complete Address'),
 299
 300         # technical field used for managing commercial fields
 301         'commercial_partner_id': fields.function(_commercial_partner_id, type='many2one', relation='res.partner', string='Commercial Entity', store=_commercial_partner_store_triggers)
 302     }
 303
 304     @api.model
 305     def _default_category(self):
 306         category_id = self.env.context.get('category_id', False)
 307         return [category_id] if category_id else False
 308
 309     @api.model
 310     def _get_default_image(self, is_company, colorize=False):
 311         img_path = openerp.modules.get_module_resource(
 312             'base', 'static/src/img', 'company_image.png' if is_company else 'avatar.png')
 313         with open(img_path, 'rb') as f:
 314             image = f.read()
 315
 316         # colorize user avatars
 317         if not is_company:
 318             image = tools.image_colorize(image)
 319
 320         return tools.image_resize_image_big(image.encode('base64'))
 321
 322     def fields_view_get(self, cr, user, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
 323         if (not view_id) and (view_type=='form') and context and context.get('force_email', False):
 324             view_id = self.pool['ir.model.data'].get_object_reference(cr, user, 'base', 'view_partner_simple_form')[1]
 325         res = super(res_partner,self).fields_view_get(cr, user, view_id, view_type, context, toolbar=toolbar, submenu=submenu)
 326         if view_type == 'form':
 327             res['arch'] = self.fields_view_get_address(cr, user, res['arch'], context=context)
 328         return res
 329
 330     @api.model
 331     def _default_company(self):
 332         return self.env['res.company']._company_default_get('res.partner')
 333
 334     _defaults = {
 335         'active': True,
 336         'lang': api.model(lambda self: self.env.lang),
 337         'tz': api.model(lambda self: self.env.context.get('tz', False)),
 338         'customer': True,
 339         'category_id': _default_category,
 340         'company_id': _default_company,
 341         'color': 0,
 342         'is_company': False,
 343         'type': 'contact', # type 'default' is wildcard and thus inappropriate
 344         'use_parent_address': False,
 345         'image': False,
 346     }
 347
 348     _constraints = [
 349         (osv.osv._check_recursion, 'You cannot create recursive Partner hierarchies.', ['parent_id']),
 350     ]
 351
 352     @api.one
 353     def copy(self, default=None):
 354         default = dict(default or {})
 355         default['name'] = _('%s (copy)') % self.name
 356         return super(res_partner, self).copy(default)
 357
 358     @api.multi
 359     def onchange_type(self, is_company):
 360         value = {'title': False}
 361         if is_company:
 362             value['use_parent_address'] = False
 363             domain = {'title': [('domain', '=', 'partner')]}
 364         else:
 365             domain = {'title': [('domain', '=', 'contact')]}
 366         return {'value': value, 'domain': domain}
 367
 368     def onchange_address(self, cr, uid, ids, use_parent_address, parent_id, context=None):
 369         def value_or_id(val):
 370             """ return val or val.id if val is a browse record """
 371             return val if isinstance(val, (bool, int, long, float, basestring)) else val.id
 372         result = {}
 373         if parent_id:
 374             if ids:
 375                 partner = self.browse(cr, uid, ids[0], context=context)
 376                 if partner.parent_id and partner.parent_id.id != parent_id:
 377                     result['warning'] = {'title': _('Warning'),
 378                                          'message': _('Changing the company of a contact should only be done if it '
 379                                                       'was never correctly set. If an existing contact starts working for a new '
 380                                                       'company then a new contact should be created under that new '
 381                                                       'company. You can use the "Discard" button to abandon this change.')}
 382             if use_parent_address:
 383                 parent = self.browse(cr, uid, parent_id, context=context)
 384                 address_fields = self._address_fields(cr, uid, context=context)
 385                 result['value'] = dict((key, value_or_id(parent[key])) for key in address_fields)
 386         else:
 387             result['value'] = {'use_parent_address': False}
 388         return result
 389
 390     @api.multi
 391     def onchange_state(self, state_id):
 392         if state_id:
 393             state = self.env['res.country.state'].browse(state_id)
 394             return {'value': {'country_id': state.country_id.id}}
 395         return {}
 396
 397     def _check_ean_key(self, cr, uid, ids, context=None):
 398         for partner_o in self.pool['res.partner'].read(cr, uid, ids, ['ean13',]):
 399             thisean=partner_o['ean13']
 400             if thisean and thisean!='':
 401                 if len(thisean)!=13:
 402                     return False
 403                 sum=0
 404                 for i in range(12):
 405                     if not (i % 2):
 406                         sum+=int(thisean[i])
 407                     else:
 408                         sum+=3*int(thisean[i])
 409                 if math.ceil(sum/10.0)*10-sum!=int(thisean[12]):
 410                     return False
 411         return True
 412
 413 #   _constraints = [(_check_ean_key, 'Error: Invalid ean code', ['ean13'])]
 414
 415     def _update_fields_values(self, cr, uid, partner, fields, context=None):
 416         """ Returns dict of write() values for synchronizing ``fields`` """
 417         values = {}
 418         for field in fields:
 419             column = self._all_columns[field].column
 420             if column._type == 'one2many':
 421                 raise AssertionError('One2Many fields cannot be synchronized as part of `commercial_fields` or `address fields`')
 422             if column._type == 'many2one':
 423                 values[field] = partner[field].id if partner[field] else False
 424             elif column._type == 'many2many':
 425                 values[field] = [(6,0,[r.id for r in partner[field] or []])]
 426             else:
 427                 values[field] = partner[field]
 428         return values
 429
 430     def _address_fields(self, cr, uid, context=None):
 431         """ Returns the list of address fields that are synced from the parent
 432         when the `use_parent_address` flag is set. """
 433         return list(ADDRESS_FIELDS)
 434
 435     def update_address(self, cr, uid, ids, vals, context=None):
 436         address_fields = self._address_fields(cr, uid, context=context)
 437         addr_vals = dict((key, vals[key]) for key in address_fields if key in vals)
 438         if addr_vals:
 439             return super(res_partner, self).write(cr, uid, ids, addr_vals, context)
 440
 441     def _commercial_fields(self, cr, uid, context=None):
 442         """ Returns the list of fields that are managed by the commercial entity
 443         to which a partner belongs. These fields are meant to be hidden on
 444         partners that aren't `commercial entities` themselves, and will be
 445         delegated to the parent `commercial entity`. The list is meant to be
 446         extended by inheriting classes. """
 447         return ['vat']
 448
 449     def _commercial_sync_from_company(self, cr, uid, partner, context=None):
 450         """ Handle sync of commercial fields when a new parent commercial entity is set,
 451         as if they were related fields """
 452         commercial_partner = partner.commercial_partner_id
 453         if not commercial_partner:
 454             # On child partner creation of a parent partner,
 455             # the commercial_partner_id is not yet computed
 456             commercial_partner_id = self._commercial_partner_compute(
 457                 cr, uid, [partner.id], 'commercial_partner_id', [], context=context)[partner.id]
 458             commercial_partner = self.browse(cr, uid, commercial_partner_id, context=context)
 459         if commercial_partner != partner:
 460             commercial_fields = self._commercial_fields(cr, uid, context=context)
 461             sync_vals = self._update_fields_values(cr, uid, commercial_partner,
 462                                                    commercial_fields, context=context)
 463             partner.write(sync_vals)
 464
 465     def _commercial_sync_to_children(self, cr, uid, partner, context=None):
 466         """ Handle sync of commercial fields to descendants """
 467         commercial_fields = self._commercial_fields(cr, uid, context=context)
 468         commercial_partner = partner.commercial_partner_id
 469         if not commercial_partner:
 470             # On child partner creation of a parent partner,
 471             # the commercial_partner_id is not yet computed
 472             commercial_partner_id = self._commercial_partner_compute(
 473                 cr, uid, [partner.id], 'commercial_partner_id', [], context=context)[partner.id]
 474             commercial_partner = self.browse(cr, uid, commercial_partner_id, context=context)
 475         sync_vals = self._update_fields_values(cr, uid, commercial_partner,
 476                                                commercial_fields, context=context)
 477         sync_children = [c for c in partner.child_ids if not c.is_company]
 478         for child in sync_children:
 479             self._commercial_sync_to_children(cr, uid, child, context=context)
 480         return self.write(cr, uid, [c.id for c in sync_children], sync_vals, context=context)
 481
 482     def _fields_sync(self, cr, uid, partner, update_values, context=None):
 483         """ Sync commercial fields and address fields from company and to children after create/update,
 484         just as if those were all modeled as fields.related to the parent """
 485         # 1. From UPSTREAM: sync from parent
 486         if update_values.get('parent_id') or update_values.get('use_parent_address'):
 487             # 1a. Commercial fields: sync if parent changed
 488             if update_values.get('parent_id'):
 489                 self._commercial_sync_from_company(cr, uid, partner, context=context)
 490             # 1b. Address fields: sync if parent or use_parent changed *and* both are now set
 491             if partner.parent_id and partner.use_parent_address:
 492                 onchange_vals = self.onchange_address(cr, uid, [partner.id],
 493                                                       use_parent_address=partner.use_parent_address,
 494                                                       parent_id=partner.parent_id.id,
 495                                                       context=context).get('value', {})
 496                 partner.update_address(onchange_vals)
 497
 498         # 2. To DOWNSTREAM: sync children
 499         if partner.child_ids:
 500             # 2a. Commercial Fields: sync if commercial entity
 501             if partner.commercial_partner_id == partner:
 502                 commercial_fields = self._commercial_fields(cr, uid,
 503                                                             context=context)
 504                 if any(field in update_values for field in commercial_fields):
 505                     self._commercial_sync_to_children(cr, uid, partner,
 506                                                       context=context)
 507             # 2b. Address fields: sync if address changed
 508             address_fields = self._address_fields(cr, uid, context=context)
 509             if any(field in update_values for field in address_fields):
 510                 domain_children = [('parent_id', '=', partner.id), ('use_parent_address', '=', True)]
 511                 update_ids = self.search(cr, uid, domain_children, context=context)
 512                 self.update_address(cr, uid, update_ids, update_values, context=context)
 513
 514     def _handle_first_contact_creation(self, cr, uid, partner, context=None):
 515         """ On creation of first contact for a company (or root) that has no address, assume contact address
 516         was meant to be company address """
 517         parent = partner.parent_id
 518         address_fields = self._address_fields(cr, uid, context=context)
 519         if parent and (parent.is_company or not parent.parent_id) and len(parent.child_ids) == 1 and \
 520             any(partner[f] for f in address_fields) and not any(parent[f] for f in address_fields):
 521             addr_vals = self._update_fields_values(cr, uid, partner, address_fields, context=context)
 522             parent.update_address(addr_vals)
 523             if not parent.is_company:
 524                 parent.write({'is_company': True})
 525
 526     def _clean_website(self, website):
 527         (scheme, netloc, path, params, query, fragment) = urlparse.urlparse(website)
 528         if not scheme:
 529             if not netloc:
 530                 netloc, path = path, ''
 531             website = urlparse.urlunparse(('http', netloc, path, params, query, fragment))
 532         return website
 533
 534     @api.multi
 535     def write(self, vals):
 536         # res.partner must only allow to set the company_id of a partner if it
 537         # is the same as the company of all users that inherit from this partner
 538         # (this is to allow the code from res_users to write to the partner!) or
 539         # if setting the company_id to False (this is compatible with any user
 540         # company)
 541         if vals.get('website'):
 542             vals['website'] = self._clean_website(vals['website'])
 543         if vals.get('company_id'):
 544             company = self.env['res.company'].browse(vals['company_id'])
 545             for partner in self:
 546                 if partner.user_ids:
 547                     companies = set(user.company_id for user in partner.user_ids)
 548                     if len(companies) > 1 or company not in companies:
 549                         raise osv.except_osv(_("Warning"),_("You can not change the company as the partner/user has multiple user linked with different companies."))
 550
 551         result = super(res_partner, self).write(vals)
 552         for partner in self:
 553             self._fields_sync(partner, vals)
 554         return result
 555
 556     @api.model
 557     def create(self, vals):
 558         if vals.get('website'):
 559             vals['website'] = self._clean_website(vals['website'])
 560         partner = super(res_partner, self).create(vals)
 561         self._fields_sync(partner, vals)
 562         self._handle_first_contact_creation(partner)
 563         return partner
 564
 565     def open_commercial_entity(self, cr, uid, ids, context=None):
 566         """ Utility method used to add an "Open Company" button in partner views """
 567         partner = self.browse(cr, uid, ids[0], context=context)
 568         return {'type': 'ir.actions.act_window',
 569                 'res_model': 'res.partner',
 570                 'view_mode': 'form',
 571                 'res_id': partner.commercial_partner_id.id,
 572                 'target': 'new',
 573                 'flags': {'form': {'action_buttons': True}}}
 574
 575     def open_parent(self, cr, uid, ids, context=None):
 576         """ Utility method used to add an "Open Parent" button in partner views """
 577         partner = self.browse(cr, uid, ids[0], context=context)
 578         return {'type': 'ir.actions.act_window',
 579                 'res_model': 'res.partner',
 580                 'view_mode': 'form',
 581                 'res_id': partner.parent_id.id,
 582                 'target': 'new',
 583                 'flags': {'form': {'action_buttons': True}}}
 584
 585     def name_get(self, cr, uid, ids, context=None):
 586         if context is None:
 587             context = {}
 588         if isinstance(ids, (int, long)):
 589             ids = [ids]
 590         res = []
 591         for record in self.browse(cr, uid, ids, context=context):
 592             name = record.name
 593             if record.parent_id and not record.is_company:
 594                 name =  "%s, %s" % (record.parent_id.name, name)
 595             if context.get('show_address_only'):
 596                 name = self._display_address(cr, uid, record, without_company=True, context=context)
 597             if context.get('show_address'):
 598                 name = name + "\n" + self._display_address(cr, uid, record, without_company=True, context=context)
 599             name = name.replace('\n\n','\n')
 600             name = name.replace('\n\n','\n')
 601             if context.get('show_email') and record.email:
 602                 name = "%s <%s>" % (name, record.email)
 603             res.append((record.id, name))
 604         return res
 605
 606     def _parse_partner_name(self, text, context=None):
 607         """ Supported syntax:
 608             - 'Raoul <raoul@grosbedon.fr>': will find name and email address
 609             - otherwise: default, everything is set as the name """
 610         emails = tools.email_split(text.replace(' ',','))
 611         if emails:
 612             email = emails[0]
 613             name = text[:text.index(email)].replace('"', '').replace('<', '').strip()
 614         else:
 615             name, email = text, ''
 616         return name, email
 617
 618     def name_create(self, cr, uid, name, context=None):
 619         """ Override of orm's name_create method for partners. The purpose is
 620             to handle some basic formats to create partners using the
 621             name_create.
 622             If only an email address is received and that the regex cannot find
 623             a name, the name will have the email value.
 624             If 'force_email' key in context: must find the email address. """
 625         if context is None:
 626             context = {}
 627         name, email = self._parse_partner_name(name, context=context)
 628         if context.get('force_email') and not email:
 629             raise osv.except_osv(_('Warning'), _("Couldn't create contact without email address!"))
 630         if not name and email:
 631             name = email
 632         rec_id = self.create(cr, uid, {self._rec_name: name or email, 'email': email or False}, context=context)
 633         return self.name_get(cr, uid, [rec_id], context)[0]
 634
 635     def _search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False, access_rights_uid=None):
 636         """ Override search() to always show inactive children when searching via ``child_of`` operator. The ORM will
 637         always call search() with a simple domain of the form [('parent_id', 'in', [ids])]. """
 638         # a special ``domain`` is set on the ``child_ids`` o2m to bypass this logic, as it uses similar domain expressions
 639         if len(args) == 1 and len(args[0]) == 3 and args[0][:2] == ('parent_id','in') \
 640                 and args[0][2] != [False]:
 641             context = dict(context or {}, active_test=False)
 642         return super(res_partner, self)._search(cr, user, args, offset=offset, limit=limit, order=order, context=context,
 643                                                 count=count, access_rights_uid=access_rights_uid)
 644
 645     def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=100):
 646         if not args:
 647             args = []
 648         if name and operator in ('=', 'ilike', '=ilike', 'like', '=like'):
 649
 650             self.check_access_rights(cr, uid, 'read')
 651             where_query = self._where_calc(cr, uid, args, context=context)
 652             self._apply_ir_rules(cr, uid, where_query, 'read', context=context)
 653             from_clause, where_clause, where_clause_params = where_query.get_sql()
 654             where_str = where_clause and (" WHERE %s AND " % where_clause) or ' WHERE '
 655
 656             # search on the name of the contacts and of its company
 657             search_name = name
 658             if operator in ('ilike', 'like'):
 659                 search_name = '%%%s%%' % name
 660             if operator in ('=ilike', '=like'):
 661                 operator = operator[1:]
 662
 663             unaccent = get_unaccent_wrapper(cr)
 664
 665             query = """SELECT id
 666                          FROM res_partner
 667                       {where} ({email} {operator} {percent}
 668                            OR {display_name} {operator} {percent})
 669                      ORDER BY {display_name}
 670                     """.format(where=where_str, operator=operator,
 671                                email=unaccent('email'),
 672                                display_name=unaccent('display_name'),
 673                                percent=unaccent('%s'))
 674
 675             where_clause_params += [search_name, search_name]
 676             if limit:
 677                 query += ' limit %s'
 678                 where_clause_params.append(limit)
 679             cr.execute(query, where_clause_params)
 680             ids = map(lambda x: x[0], cr.fetchall())
 681
 682             if ids:
 683                 return self.name_get(cr, uid, ids, context)
 684             else:
 685                 return []
 686         return super(res_partner,self).name_search(cr, uid, name, args, operator=operator, context=context, limit=limit)
 687
 688     def find_or_create(self, cr, uid, email, context=None):
 689         """ Find a partner with the given ``email`` or use :py:method:`~.name_create`
 690             to create one
 691
 692             :param str email: email-like string, which should contain at least one email,
 693                 e.g. ``"Raoul Grosbedon <r.g@grosbedon.fr>"``"""
 694         assert email, 'an email is required for find_or_create to work'
 695         emails = tools.email_split(email)
 696         if emails:
 697             email = emails[0]
 698         ids = self.search(cr, uid, [('email','ilike',email)], context=context)
 699         if not ids:
 700             return self.name_create(cr, uid, email, context=context)[0]
 701         return ids[0]
 702
 703     def _email_send(self, cr, uid, ids, email_from, subject, body, on_error=None):
 704         partners = self.browse(cr, uid, ids)
 705         for partner in partners:
 706             if partner.email:
 707                 tools.email_send(email_from, [partner.email], subject, body, on_error)
 708         return True
 709
 710     def email_send(self, cr, uid, ids, email_from, subject, body, on_error=''):
 711         while len(ids):
 712             self.pool['ir.cron'].create(cr, uid, {
 713                 'name': 'Send Partner Emails',
 714                 'user_id': uid,
 715                 'model': 'res.partner',
 716                 'function': '_email_send',
 717                 'args': repr([ids[:16], email_from, subject, body, on_error])
 718             })
 719             ids = ids[16:]
 720         return True
 721
 722     def address_get(self, cr, uid, ids, adr_pref=None, context=None):
 723         """ Find contacts/addresses of the right type(s) by doing a depth-first-search
 724         through descendants within company boundaries (stop at entities flagged ``is_company``)
 725         then continuing the search at the ancestors that are within the same company boundaries.
 726         Defaults to partners of type ``'default'`` when the exact type is not found, or to the
 727         provided partner itself if no type ``'default'`` is found either. """
 728         adr_pref = set(adr_pref or [])
 729         if 'default' not in adr_pref:
 730             adr_pref.add('default')
 731         result = {}
 732         visited = set()
 733         for partner in self.browse(cr, uid, filter(None, ids), context=context):
 734             current_partner = partner
 735             while current_partner:
 736                 to_scan = [current_partner]
 737                 # Scan descendants, DFS
 738                 while to_scan:
 739                     record = to_scan.pop(0)
 740                     visited.add(record)
 741                     if record.type in adr_pref and not result.get(record.type):
 742                         result[record.type] = record.id
 743                     if len(result) == len(adr_pref):
 744                         return result
 745                     to_scan = [c for c in record.child_ids
 746                                  if c not in visited
 747                                  if not c.is_company] + to_scan
 748
 749                 # Continue scanning at ancestor if current_partner is not a commercial entity
 750                 if current_partner.is_company or not current_partner.parent_id:
 751                     break
 752                 current_partner = current_partner.parent_id
 753
 754         # default to type 'default' or the partner itself
 755         default = result.get('default', partner.id)
 756         for adr_type in adr_pref:
 757             result[adr_type] = result.get(adr_type) or default
 758         return result
 759
 760     def view_header_get(self, cr, uid, view_id, view_type, context):
 761         res = super(res_partner, self).view_header_get(cr, uid, view_id, view_type, context)
 762         if res: return res
 763         if not context.get('category_id', False):
 764             return False
 765         return _('Partners: ')+self.pool['res.partner.category'].browse(cr, uid, context['category_id'], context).name
 766
 767     @api.model
 768     @api.returns('self')
 769     def main_partner(self):
 770         ''' Return the main partner '''
 771         return self.env.ref('base.main_partner')
 772
 773     def _display_address(self, cr, uid, address, without_company=False, context=None):
 774
 775         '''
 776         The purpose of this function is to build and return an address formatted accordingly to the
 777         standards of the country where it belongs.
 778
 779         :param address: browse record of the res.partner to format
 780         :returns: the address formatted in a display that fit its country habits (or the default ones
 781             if not country is specified)
 782         :rtype: string
 783         '''
 784
 785         # get the information that will be injected into the display format
 786         # get the address format
 787         address_format = address.country_id.address_format or \
 788               "%(street)s\n%(street2)s\n%(city)s %(state_code)s %(zip)s\n%(country_name)s"
 789         args = {
 790             'state_code': address.state_id.code or '',
 791             'state_name': address.state_id.name or '',
 792             'country_code': address.country_id.code or '',
 793             'country_name': address.country_id.name or '',
 794             'company_name': address.parent_id.name or '',
 795         }
 796         for field in self._address_fields(cr, uid, context=context):
 797             args[field] = getattr(address, field) or ''
 798         if without_company:
 799             args['company_name'] = ''
 800         elif address.parent_id:
 801             address_format = '%(company_name)s\n' + address_format
 802         return address_format % args
 803
 804 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: