addons/crm/crm.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2010 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 time
  23 import base64
  24 import tools
  25
  26 from osv import fields
  27 from osv import osv
  28 from tools.translate import _
  29
  30 MAX_LEVEL = 15
  31 AVAILABLE_STATES = [
  32     ('draft', 'Draft'),
  33     ('open', 'Open'),
  34     ('cancel', 'Cancelled'),
  35     ('done', 'Closed'),
  36     ('pending', 'Pending'),
  37 ]
  38
  39 AVAILABLE_PRIORITIES = [
  40     ('1', 'Highest'),
  41     ('2', 'High'),
  42     ('3', 'Normal'),
  43     ('4', 'Low'),
  44     ('5', 'Lowest'),
  45 ]
  46
  47 class crm_case(object):
  48     """A simple python class to be used for common functions """
  49
  50     def _find_lost_stage(self, cr, uid, type, section_id):
  51         return self._find_percent_stage(cr, uid, 0.0, type, section_id)
  52
  53     def _find_won_stage(self, cr, uid, type, section_id):
  54         return self._find_percent_stage(cr, uid, 100.0, type, section_id)
  55
  56     def _find_percent_stage(self, cr, uid, percent, type, section_id):
  57         """
  58             Return the first stage with a probability == percent
  59         """
  60         stage_pool = self.pool.get('crm.case.stage')
  61         if section_id :
  62             ids = stage_pool.search(cr, uid, [("probability", '=', percent), ("type", 'like', type), ("section_ids", 'in', [section_id])])
  63         else :
  64             ids = stage_pool.search(cr, uid, [("probability", '=', percent), ("type", 'like', type)])
  65
  66         if ids:
  67             return ids[0]
  68         return False
  69
  70
  71     def _find_first_stage(self, cr, uid, type, section_id):
  72         """
  73             return the first stage that has a sequence number equal or higher than sequence
  74         """
  75         stage_pool = self.pool.get('crm.case.stage')
  76         if section_id :
  77             ids = stage_pool.search(cr, uid, [("sequence", '>', 0), ("type", 'like', type), ("section_ids", 'in', [section_id])])
  78         else :
  79             ids = stage_pool.search(cr, uid, [("sequence", '>', 0), ("type", 'like', type)])
  80
  81         if ids:
  82             stages = stage_pool.browse(cr, uid, ids)
  83             stage_min = stages[0]
  84             for stage in stages:
  85                 if stage_min.sequence > stage.sequence:
  86                     stage_min = stage
  87             return stage_min.id
  88         else :
  89             return False
  90
  91     def onchange_stage_id(self, cr, uid, ids, stage_id, context={}):
  92
  93         """ @param self: The object pointer
  94             @param cr: the current row, from the database cursor,
  95             @param uid: the current user’s ID for security checks,
  96             @param ids: List of stage’s IDs
  97             @stage_id: change state id on run time """
  98
  99         if not stage_id:
 100             return {'value':{}}
 101
 102         stage = self.pool.get('crm.case.stage').browse(cr, uid, stage_id, context)
 103
 104         if not stage.on_change:
 105             return {'value':{}}
 106         return {'value':{'probability': stage.probability}}
 107
 108     def _get_default_partner_address(self, cr, uid, context=None):
 109
 110         """Gives id of default address for current user
 111         @param self: The object pointer
 112         @param cr: the current row, from the database cursor,
 113         @param uid: the current user’s ID for security checks,
 114         @param context: A standard dictionary for contextual values
 115         """
 116         if context is None:
 117             context = {}
 118         if not context.get('portal', False):
 119             return False
 120         return self.pool.get('res.users').browse(cr, uid, uid, context).address_id.id
 121
 122     def _get_default_partner(self, cr, uid, context=None):
 123         """Gives id of partner for current user
 124         @param self: The object pointer
 125         @param cr: the current row, from the database cursor,
 126         @param uid: the current user’s ID for security checks,
 127         @param context: A standard dictionary for contextual values
 128         """
 129         if context is None:
 130             context = {}
 131         if not context.get('portal', False):
 132             return False
 133         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 134         if not user.address_id:
 135             return False
 136         return user.address_id.partner_id.id
 137
 138     def copy(self, cr, uid, id, default=None, context=None):
 139         """
 140         Overrides orm copy method.
 141         @param self: the object pointer
 142         @param cr: the current row, from the database cursor,
 143         @param uid: the current user’s ID for security checks,
 144         @param id: Id of mailgate thread
 145         @param default: Dictionary of default values for copy.
 146         @param context: A standard dictionary for contextual values
 147         """
 148         if context is None:
 149             context = {}
 150         if default is None:
 151             default = {}
 152
 153         default.update({
 154                     'message_ids': [],
 155                 })
 156         if hasattr(self, '_columns'):
 157             if self._columns.get('date_closed'):
 158                 default.update({
 159                     'date_closed': False,
 160                 })
 161             if self._columns.get('date_open'):
 162                 default.update({
 163                     'date_open': False
 164                 })
 165         return super(osv.osv, self).copy(cr, uid, id, default, context=context)
 166
 167     def _get_default_email(self, cr, uid, context=None):
 168         """Gives default email address for current user
 169         @param self: The object pointer
 170         @param cr: the current row, from the database cursor,
 171         @param uid: the current user’s ID for security checks,
 172         @param context: A standard dictionary for contextual values
 173         """
 174         if not context.get('portal', False):
 175             return False
 176         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 177         if not user.address_id:
 178             return False
 179         return user.address_id.email
 180
 181     def _get_default_user(self, cr, uid, context=None):
 182         """Gives current user id
 183         @param self: The object pointer
 184         @param cr: the current row, from the database cursor,
 185         @param uid: the current user’s ID for security checks,
 186         @param context: A standard dictionary for contextual values
 187         """
 188         if context and context.get('portal', False):
 189             return False
 190         return uid
 191
 192     def _get_section(self, cr, uid, context=None):
 193         """Gives section id for current User
 194         @param self: The object pointer
 195         @param cr: the current row, from the database cursor,
 196         @param uid: the current user’s ID for security checks,
 197         @param context: A standard dictionary for contextual values
 198         """
 199         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 200         return user.context_section_id.id or False
 201
 202     def _find_next_stage(self, cr, uid, stage_list, index, current_seq, stage_pool, context=None):
 203         if index + 1 == len(stage_list):
 204             return False
 205         next_stage_id = stage_list[index + 1]
 206         next_stage = stage_pool.browse(cr, uid, next_stage_id, context=context)
 207         if not next_stage:
 208             return False
 209         next_seq = next_stage.sequence
 210         if not current_seq :
 211             current_seq = 0
 212
 213         if (abs(next_seq - current_seq)) >= 1:
 214             return next_stage
 215         else :
 216             return self._find_next_stage(cr, uid, stage_list, index + 1, current_seq, stage_pool)
 217
 218     def stage_change(self, cr, uid, ids, context=None, order='sequence'):
 219         if context is None:
 220             context = {}
 221
 222         stage_pool = self.pool.get('crm.case.stage')
 223         stage_type = context and context.get('stage_type','')
 224         current_seq = False
 225         next_stage_id = False
 226
 227         for case in self.browse(cr, uid, ids, context=context):
 228
 229             next_stage = False
 230             value = {}
 231             if case.section_id.id :
 232                 domain = [('type', '=', stage_type),('section_ids', '=', case.section_id.id)]
 233             else :
 234                 domain = [('type', '=', stage_type)]
 235
 236
 237             stages = stage_pool.search(cr, uid, domain, order=order)
 238             current_seq = case.stage_id.sequence
 239             index = -1
 240             if case.stage_id and case.stage_id.id in stages:
 241                 index = stages.index(case.stage_id.id)
 242
 243             next_stage = self._find_next_stage(cr, uid, stages, index, current_seq, stage_pool, context=context)
 244
 245             if next_stage:
 246                 next_stage_id = next_stage.id
 247                 value.update({'stage_id': next_stage.id})
 248                 if next_stage.on_change:
 249                     value.update({'probability': next_stage.probability})
 250             self.write(cr, uid, [case.id], value, context=context)
 251
 252
 253         return next_stage_id #FIXME should return a list of all id
 254
 255
 256     def stage_next(self, cr, uid, ids, context=None):
 257         """This function computes next stage for case from its current stage
 258              using available stage for that case type
 259         @param self: The object pointer
 260         @param cr: the current row, from the database cursor,
 261         @param uid: the current user’s ID for security checks,
 262         @param ids: List of case IDs
 263         @param context: A standard dictionary for contextual values"""
 264
 265         return self.stage_change(cr, uid, ids, context=context, order='sequence')
 266
 267     def stage_previous(self, cr, uid, ids, context=None):
 268         """This function computes previous stage for case from its current stage
 269              using available stage for that case type
 270         @param self: The object pointer
 271         @param cr: the current row, from the database cursor,
 272         @param uid: the current user’s ID for security checks,
 273         @param ids: List of case IDs
 274         @param context: A standard dictionary for contextual values"""
 275         return self.stage_change(cr, uid, ids, context=context, order='sequence desc')
 276
 277     def onchange_partner_id(self, cr, uid, ids, part, email=False):
 278         """This function returns value of partner address based on partner
 279         @param self: The object pointer
 280         @param cr: the current row, from the database cursor,
 281         @param uid: the current user’s ID for security checks,
 282         @param ids: List of case IDs
 283         @param part: Partner's id
 284         @email: Partner's email ID
 285         """
 286         data={}
 287         if  part:
 288             addr = self.pool.get('res.partner').address_get(cr, uid, [part], ['contact'])
 289             data = {'partner_address_id': addr['contact']}
 290             data.update(self.onchange_partner_address_id(cr, uid, ids, addr['contact'])['value'])
 291         return {'value': data}
 292
 293     def onchange_partner_address_id(self, cr, uid, ids, add, email=False):
 294         """This function returns value of partner email based on Partner Address
 295         @param self: The object pointer
 296         @param cr: the current row, from the database cursor,
 297         @param uid: the current user’s ID for security checks,
 298         @param ids: List of case IDs
 299         @param add: Id of Partner's address
 300         @email: Partner's email ID
 301         """
 302         if not add:
 303             return {'value': {'email_from': False}}
 304         address = self.pool.get('res.partner.address').browse(cr, uid, add)
 305         if address.email:
 306             return {'value': {'email_from': address.email, 'phone': address.phone}}
 307         else:
 308             return {'value': {'phone': address.phone}}
 309
 310     def _history(self, cr, uid, cases, keyword, history=False, subject=None, email=False, details=None, email_from=False, message_id=False, attach=[], context=None):
 311         mailgate_pool = self.pool.get('mailgate.thread')
 312         return mailgate_pool.history(cr, uid, cases, keyword, history=history,\
 313                                        subject=subject, email=email, \
 314                                        details=details, email_from=email_from,\
 315                                        message_id=message_id, attach=attach, \
 316                                        context=context)
 317
 318     def case_open(self, cr, uid, ids, *args):
 319         """Opens Case
 320         @param self: The object pointer
 321         @param cr: the current row, from the database cursor,
 322         @param uid: the current user’s ID for security checks,
 323         @param ids: List of case Ids
 324         @param *args: Tuple Value for additional Params
 325         """
 326
 327         cases = self.browse(cr, uid, ids)
 328         self._history(cr, uid, cases, _('Open'))
 329         for case in cases:
 330             data = {'state': 'open', 'active': True}
 331             if not case.user_id:
 332                 data['user_id'] = uid
 333             self.write(cr, uid, case.id, data)
 334         self._action(cr, uid, cases, 'open')
 335         return True
 336
 337     def case_close(self, cr, uid, ids, *args):
 338         """Closes Case
 339         @param self: The object pointer
 340         @param cr: the current row, from the database cursor,
 341         @param uid: the current user’s ID for security checks,
 342         @param ids: List of case Ids
 343         @param *args: Tuple Value for additional Params
 344         """
 345         cases = self.browse(cr, uid, ids)
 346         cases[0].state # to fill the browse record cache
 347         self._history(cr, uid, cases, _('Close'))
 348         self.write(cr, uid, ids, {'state': 'done',
 349                                   'date_closed': time.strftime('%Y-%m-%d %H:%M:%S'),
 350                                   })
 351         #
 352         # We use the cache of cases to keep the old case state
 353         #
 354         self._action(cr, uid, cases, 'done')
 355         return True
 356
 357     def case_escalate(self, cr, uid, ids, *args):
 358         """Escalates case to top level
 359         @param self: The object pointer
 360         @param cr: the current row, from the database cursor,
 361         @param uid: the current user’s ID for security checks,
 362         @param ids: List of case Ids
 363         @param *args: Tuple Value for additional Params
 364         """
 365         cases = self.browse(cr, uid, ids)
 366         for case in cases:
 367             data = {'active': True}
 368
 369             if case.section_id.parent_id:
 370                 data['section_id'] = case.section_id.parent_id.id
 371                 if case.section_id.parent_id.change_responsible:
 372                     if case.section_id.parent_id.user_id:
 373                         data['user_id'] = case.section_id.parent_id.user_id.id
 374             else:
 375                 raise osv.except_osv(_('Error !'), _('You can not escalate, You are already at the top level regarding your sales-team category.'))
 376             self.write(cr, uid, [case.id], data)
 377         cases = self.browse(cr, uid, ids)
 378         self._history(cr, uid, cases, _('Escalate'))
 379         self._action(cr, uid, cases, 'escalate')
 380         return True
 381
 382     def case_cancel(self, cr, uid, ids, *args):
 383         """Cancels Case
 384         @param self: The object pointer
 385         @param cr: the current row, from the database cursor,
 386         @param uid: the current user’s ID for security checks,
 387         @param ids: List of case Ids
 388         @param *args: Tuple Value for additional Params
 389         """
 390         cases = self.browse(cr, uid, ids)
 391         cases[0].state # to fill the browse record cache
 392         self._history(cr, uid, cases, _('Cancel'))
 393         self.write(cr, uid, ids, {'state': 'cancel',
 394                                   'active': True})
 395         self._action(cr, uid, cases, 'cancel')
 396         for case in cases:
 397             message = _("The case '%s' has been cancelled.") % (case.name,)
 398             self.log(cr, uid, case.id, message)
 399         return True
 400
 401     def case_pending(self, cr, uid, ids, *args):
 402         """Marks case as pending
 403         @param self: The object pointer
 404         @param cr: the current row, from the database cursor,
 405         @param uid: the current user’s ID for security checks,
 406         @param ids: List of case Ids
 407         @param *args: Tuple Value for additional Params
 408         """
 409         cases = self.browse(cr, uid, ids)
 410         cases[0].state # to fill the browse record cache
 411         self._history(cr, uid, cases, _('Pending'))
 412         self.write(cr, uid, ids, {'state': 'pending', 'active': True})
 413         self._action(cr, uid, cases, 'pending')
 414         return True
 415
 416     def case_reset(self, cr, uid, ids, *args):
 417         """Resets case as draft
 418         @param self: The object pointer
 419         @param cr: the current row, from the database cursor,
 420         @param uid: the current user’s ID for security checks,
 421         @param ids: List of case Ids
 422         @param *args: Tuple Value for additional Params
 423         """
 424         state = 'draft'
 425         if 'crm.phonecall' in args:
 426             state = 'open'
 427         cases = self.browse(cr, uid, ids)
 428         cases[0].state # to fill the browse record cache
 429         self._history(cr, uid, cases, _('Draft'))
 430         self.write(cr, uid, ids, {'state': state, 'active': True})
 431         self._action(cr, uid, cases, state)
 432         return True
 433
 434     def remind_partner(self, cr, uid, ids, context=None, attach=False):
 435
 436         """
 437         @param self: The object pointer
 438         @param cr: the current row, from the database cursor,
 439         @param uid: the current user’s ID for security checks,
 440         @param ids: List of Remind Partner's IDs
 441         @param context: A standard dictionary for contextual values
 442
 443         """
 444
 445         return self.remind_user(cr, uid, ids, context, attach,
 446                 destination=False)
 447
 448     def remind_user(self, cr, uid, ids, context=None, attach=False, destination=True):
 449         """
 450         @param self: The object pointer
 451         @param cr: the current row, from the database cursor,
 452         @param uid: the current user’s ID for security checks,
 453         @param ids: List of case's IDs to remind
 454         @param context: A standard dictionary for contextual values
 455         """
 456         for case in self.browse(cr, uid, ids, context=context):
 457             if not destination and not case.email_from:
 458                 return False
 459             if not case.user_id.user_email:
 460                 return False
 461
 462             if destination and case.section_id.user_id:
 463                 case_email = case.section_id.user_id.user_email
 464             else:
 465                 case_email = case.user_id.user_email
 466
 467             src = case_email
 468             dest = case.user_id
 469             body = case.description or ""
 470             if case.message_ids:
 471                 body = case.message_ids[0].description or ""
 472             if not destination:
 473                 src, dest = dest, case.email_from
 474                 if body and case.user_id.signature:
 475                     if body:
 476                         body += '\n\n%s' % (case.user_id.signature)
 477                     else:
 478                         body = '\n\n%s' % (case.user_id.signature)
 479
 480             body = self.format_body(body)
 481
 482             attach_to_send = None
 483
 484             if attach:
 485                 attach_ids = self.pool.get('ir.attachment').search(cr, uid, [('res_model', '=', self._name), ('res_id', '=', case.id)])
 486                 attach_to_send = self.pool.get('ir.attachment').read(cr, uid, attach_ids, ['datas_fname', 'datas'])
 487                 attach_to_send = map(lambda x: (x['datas_fname'], base64.decodestring(x['datas'])), attach_to_send)
 488
 489                 # Send an email
 490             subject = "Reminder: [%s] %s" % (str(case.id), case.name,)
 491             tools.email_send(
 492                 src,
 493                 [dest],
 494                 subject,
 495                 body,
 496                 reply_to=case.section_id.reply_to or '',
 497                 openobject_id=str(case.id),
 498                 attach=attach_to_send
 499             )
 500             self._history(cr, uid, [case], _('Send'), history=True, subject=subject, email=dest, details=body, email_from=src)
 501
 502         return True
 503
 504     def _check(self, cr, uid, ids=False, context=None):
 505         """
 506         Function called by the scheduler to process cases for date actions
 507         Only works on not done and cancelled cases
 508
 509         @param self: The object pointer
 510         @param cr: the current row, from the database cursor,
 511         @param uid: the current user’s ID for security checks,
 512         @param context: A standard dictionary for contextual values
 513         """
 514         cr.execute('select * from crm_case \
 515                 where (date_action_last<%s or date_action_last is null) \
 516                 and (date_action_next<=%s or date_action_next is null) \
 517                 and state not in (\'cancel\',\'done\')',
 518                 (time.strftime("%Y-%m-%d %H:%M:%S"),
 519                     time.strftime('%Y-%m-%d %H:%M:%S')))
 520
 521         ids2 = map(lambda x: x[0], cr.fetchall() or [])
 522         cases = self.browse(cr, uid, ids2, context=context)
 523         return self._action(cr, uid, cases, False, context=context)
 524
 525     def _action(self, cr, uid, cases, state_to, scrit=None, context=None):
 526         if context is None:
 527             context = {}
 528         context['state_to'] = state_to
 529         rule_obj = self.pool.get('base.action.rule')
 530         model_obj = self.pool.get('ir.model')
 531         model_ids = model_obj.search(cr, uid, [('model','=',self._name)])
 532         rule_ids = rule_obj.search(cr, uid, [('model_id','=',model_ids[0])])
 533         return rule_obj._action(cr, uid, rule_ids, cases, scrit=scrit, context=context)
 534
 535     def format_body(self, body):
 536         return self.pool.get('base.action.rule').format_body(body)
 537
 538     def format_mail(self, obj, body):
 539         return self.pool.get('base.action.rule').format_mail(obj, body)
 540
 541     def message_followers(self, cr, uid, ids, context=None):
 542         """ Get a list of emails of the people following this thread
 543         """
 544         res = {}
 545         for case in self.browse(cr, uid, ids, context=context):
 546             l=[]
 547             if case.email_cc:
 548                 l.append(case.email_cc)
 549             if case.user_id and case.user_id.user_email:
 550                 l.append(case.user_id.user_email)
 551             res[case.id] = l
 552         return res
 553
 554
 555 class crm_case_stage(osv.osv):
 556     """ Stage of case """
 557
 558     _name = "crm.case.stage"
 559     _description = "Stage of case"
 560     _rec_name = 'name'
 561     _order = "sequence"
 562
 563
 564
 565     def _get_type_value(self, cr, user, context):
 566         return [('lead','Lead'),('opportunity','Opportunity')]
 567
 568
 569     _columns = {
 570         'name': fields.char('Stage Name', size=64, required=True, translate=True),
 571         'sequence': fields.integer('Sequence', help="Gives the sequence order when displaying a list of case stages."),
 572         'probability': fields.float('Probability (%)', required=True, help="This percentage depicts the default/average probability of the Case for this stage to be a success"),
 573         'on_change': fields.boolean('Change Probability Automatically', \
 574                          help="Change Probability on next and previous stages."),
 575         'requirements': fields.text('Requirements'),
 576         'type': fields.selection(_get_type_value, 'Type', required=True),
 577     }
 578
 579
 580     def _find_stage_type(self, cr, uid, context=None):
 581         """Finds type of stage according to object.
 582         @param self: The object pointer
 583         @param cr: the current row, from the database cursor,
 584         @param uid: the current user’s ID for security checks,
 585         @param context: A standard dictionary for contextual values
 586         """
 587         type = context and context.get('type', '') or ''
 588         return type
 589
 590     _defaults = {
 591         'sequence': lambda *args: 1,
 592         'probability': lambda *args: 0.0,
 593         'type': _find_stage_type,
 594     }
 595
 596 crm_case_stage()
 597
 598
 599 class crm_case_section(osv.osv):
 600     """Sales Team"""
 601
 602     _name = "crm.case.section"
 603     _description = "Sales Teams"
 604     _order = "complete_name"
 605
 606     def get_full_name(self, cr, uid, ids, field_name, arg, context=None):
 607         return  dict(self.name_get(cr, uid, ids, context=context))
 608
 609     _columns = {
 610         'name': fields.char('Sales Team', size=64, required=True, translate=True),
 611         'complete_name': fields.function(get_full_name, method=True, type='char', size=256, readonly=True, store=True),
 612         'code': fields.char('Code', size=8),
 613         'active': fields.boolean('Active', help="If the active field is set to "\
 614                         "true, it will allow you to hide the sales team without removing it."),
 615         'allow_unlink': fields.boolean('Allow Delete', help="Allows to delete non draft cases"),
 616         'change_responsible': fields.boolean('Change Responsible', help="Thick this box if you want that on escalation, the responsible of this sale team automatically becomes responsible of the lead/opportunity escaladed"),
 617         'user_id': fields.many2one('res.users', 'Responsible User'),
 618         'member_ids':fields.many2many('res.users', 'sale_member_rel', 'section_id', 'member_id', 'Team Members'),
 619         'reply_to': fields.char('Reply-To', size=64, help="The email address put in the 'Reply-To' of all emails sent by OpenERP about cases in this sales team"),
 620         'parent_id': fields.many2one('crm.case.section', 'Parent Team'),
 621         'child_ids': fields.one2many('crm.case.section', 'parent_id', 'Child Teams'),
 622         'resource_calendar_id': fields.many2one('resource.calendar', "Working Time"),
 623         'note': fields.text('Description'),
 624         'working_hours': fields.float('Working Hours', digits=(16,2 )),
 625         'stage_ids': fields.many2many('crm.case.stage', 'section_stage_rel', 'section_id', 'stage_id', 'Stages'),
 626     }
 627
 628     _defaults = {
 629         'active': lambda *a: 1,
 630         'allow_unlink': lambda *a: 1,
 631     }
 632
 633     _sql_constraints = [
 634         ('code_uniq', 'unique (code)', 'The code of the sales team must be unique !')
 635     ]
 636
 637     def _check_recursion(self, cr, uid, ids, context=None):
 638
 639         """
 640         Checks for recursion level for sales team
 641         @param self: The object pointer
 642         @param cr: the current row, from the database cursor,
 643         @param uid: the current user’s ID for security checks,
 644         @param ids: List of Sales team ids
 645         """
 646         level = 100
 647
 648         while len(ids):
 649             cr.execute('select distinct parent_id from crm_case_section where id IN %s', (tuple(ids),))
 650             ids = filter(None, map(lambda x: x[0], cr.fetchall()))
 651             if not level:
 652                 return False
 653             level -= 1
 654
 655         return True
 656
 657     _constraints = [
 658         (_check_recursion, 'Error ! You cannot create recursive Sales team.', ['parent_id'])
 659     ]
 660
 661     def name_get(self, cr, uid, ids, context=None):
 662         """Overrides orm name_get method
 663         @param self: The object pointer
 664         @param cr: the current row, from the database cursor,
 665         @param uid: the current user’s ID for security checks,
 666         @param ids: List of sales team ids
 667         """
 668         if context is None:
 669             context = {}
 670
 671         res = []
 672         if not ids:
 673             return res
 674         reads = self.read(cr, uid, ids, ['name', 'parent_id'], context)
 675
 676         for record in reads:
 677             name = record['name']
 678             if record['parent_id']:
 679                 name = record['parent_id'][1] + ' / ' + name
 680             res.append((record['id'], name))
 681         return res
 682
 683 crm_case_section()
 684
 685
 686 class crm_case_categ(osv.osv):
 687     """ Category of Case """
 688     _name = "crm.case.categ"
 689     _description = "Category of Case"
 690     _columns = {
 691         'name': fields.char('Name', size=64, required=True, translate=True),
 692         'section_id': fields.many2one('crm.case.section', 'Sales Team'),
 693         'object_id': fields.many2one('ir.model', 'Object Name'),
 694     }
 695
 696     def _find_object_id(self, cr, uid, context=None):
 697         """Finds id for case object
 698         @param self: The object pointer
 699         @param cr: the current row, from the database cursor,
 700         @param uid: the current user’s ID for security checks,
 701         @param context: A standard dictionary for contextual values
 702         """
 703
 704         object_id = context and context.get('object_id', False) or False
 705         ids = self.pool.get('ir.model').search(cr, uid, [('model', '=', object_id)])
 706         return ids and ids[0]
 707
 708     _defaults = {
 709         'object_id' : _find_object_id
 710
 711     }
 712 crm_case_categ()
 713
 714
 715 class crm_case_stage(osv.osv):
 716     _inherit = "crm.case.stage"
 717     _columns = {
 718         'section_ids':fields.many2many('crm.case.section', 'section_stage_rel', 'stage_id', 'section_id', 'Sections'),
 719     }
 720
 721 crm_case_stage()
 722
 723
 724 class crm_case_resource_type(osv.osv):
 725     """ Resource Type of case """
 726     _name = "crm.case.resource.type"
 727     _description = "Campaign"
 728     _rec_name = "name"
 729     _columns = {
 730         'name': fields.char('Campaign Name', size=64, required=True, translate=True),
 731         'section_id': fields.many2one('crm.case.section', 'Sales Team'),
 732     }
 733 crm_case_resource_type()
 734
 735
 736 def _links_get(self, cr, uid, context=None):
 737     """Gets links value for reference field
 738     @param self: The object pointer
 739     @param cr: the current row, from the database cursor,
 740     @param uid: the current user’s ID for security checks,
 741     @param context: A standard dictionary for contextual values
 742     """
 743     obj = self.pool.get('res.request.link')
 744     ids = obj.search(cr, uid, [])
 745     res = obj.read(cr, uid, ids, ['object', 'name'], context)
 746     return [(r['object'], r['name']) for r in res]
 747
 748 class users(osv.osv):
 749     _inherit = 'res.users'
 750     _description = "Users"
 751     _columns = {
 752         'context_section_id': fields.many2one('crm.case.section', 'Sales Team'),
 753     }
 754
 755     def create(self, cr, uid, vals, context=None):
 756         res = super(users, self).create(cr, uid, vals, context=context)
 757         section_obj=self.pool.get('crm.case.section')
 758
 759         if vals.get('context_section_id', False):
 760             section_obj.write(cr, uid, [vals['context_section_id']], {'member_ids':[(4, res)]}, context)
 761         return res
 762 users()
 763
 764
 765 class res_partner(osv.osv):
 766     _inherit = 'res.partner'
 767     _columns = {
 768         'section_id': fields.many2one('crm.case.section', 'Sales Team'),
 769     }
 770 res_partner()
 771