← Back to branch summary

~jgrandguillaume-c2c/openobject-addons/multi-company-cost-price

« back to all changes in this revision

Viewing changes to crm/wizard/crm_lead_wizard.py

  • Committer: Joël Grand-Guillaume
  • Date: 2010-04-08 09:00:10 UTC
  • mfrom: (2533.3.664)
  • Revision ID: joel.grandguillaume@camptocamp.com-20100408090010-c0pqjan341s18bxs
[MRG] Merge from last trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
crm/wizard/crm_lead_wizard.py
27
27
import pooler
28
28
from tools.translate import _
29
29
 
30
 
class lead2opportunity(wizard.interface):
 
30
class partner_create(wizard.interface):
 
31
 
 
32
    case_form = """<?xml version="1.0"?>
 
33
    <form string="Create a Partner">
 
34
        <label string="Are you sure you want to create a partner based on this lead ?" colspan="4"/>
 
35
        <label string="You may have to verify that this partner does not exist already." colspan="4"/>
 
36
        <!--field name="close"/-->
 
37
    </form>"""
 
38
 
 
39
    case_fields = {
 
40
        'close': {'type':'boolean', 'string':'Close Lead'}
 
41
    }
31
42
 
32
43
    partner_form = """<?xml version="1.0"?>
33
 
    <form string="Convert To Partner">
 
44
    <form string="Create a Partner">
34
45
        <label string="Are you sure you want to create a partner based on this lead ?" colspan="4"/>
35
46
        <label string="You may have to verify that this partner does not exist already." colspan="4"/>
36
47
        <newline />
37
48
        <field name="action"/>
38
 
        <group attrs="{'invisible':[('action','=','create')]}">
39
 
            <field name="partner_id" attrs="{'required':[('action','=','exist')]}"/>
 
49
        <group attrs="{'invisible':[('action','!=','exist')]}">
 
50
            <field name="partner_id"/>
40
51
        </group>
41
52
    </form>"""
42
53
 
43
54
    partner_fields = {
44
55
        'action': {'type':'selection',
45
56
                'selection':[('exist','Link to an existing partner'),('create','Create a new partner')],
46
 
                'string':'Action', 'required':True, 'default': lambda *a:'create'},
 
57
                'string':'Action', 'required':True, 'default': lambda *a:'exist'},
47
58
        'partner_id' : {'type':'many2one', 'relation':'res.partner', 'string':'Partner'},
48
59
    }
 
60
    
 
61
    def _selectPartner(self, cr, uid, data, context):
 
62
        pool = pooler.get_pool(cr.dbname)
 
63
        case_obj = pool.get('crm.lead')
 
64
        partner_obj = pool.get('res.partner')
 
65
        contact_obj = pool.get('res.partner.address')
 
66
        for case in case_obj.browse(cr, uid, data['ids']):
 
67
            if case.partner_id:
 
68
                raise wizard.except_wizard(_('Warning !'),
 
69
                    _('A partner is already defined on this lead.'))
 
70
           
 
71
            partner_ids = partner_obj.search(cr, uid, [('name', '=', case.partner_name or case.name)])            
 
72
            if not partner_ids and case.email_from:
 
73
                address_ids = contact_obj.search(cr, uid, [('email', '=', case.email_from)])
 
74
                if address_ids:
 
75
                    addresses = contact_obj.browse(cr, uid, address_ids)
 
76
                    partner_ids = addresses and [addresses[0].partner_id.id] or False
 
77
 
 
78
            partner_id = partner_ids and partner_ids[0] or False
 
79
        vals = {'partner_id': partner_id}
 
80
        if not partner_id:
 
81
            vals['action'] = 'create'            
 
82
        return vals
 
83
 
 
84
    def _create_partner(self, cr, uid, data, context):
 
85
        pool = pooler.get_pool(cr.dbname)        
 
86
        case_obj = pool.get('crm.lead')
 
87
        partner_obj = pool.get('res.partner')
 
88
        contact_obj = pool.get('res.partner.address')
 
89
        partner_ids = []
 
90
        partner_id = False
 
91
        contact_id = False
 
92
        for case in case_obj.browse(cr, uid, data['ids']):
 
93
            if data['form']['action'] == 'create':
 
94
                partner_id = partner_obj.create(cr, uid, {
 
95
                    'name': case.partner_name or case.name,
 
96
                    'user_id': case.user_id.id,
 
97
                    'comment': case.description,
 
98
                })
 
99
                contact_id = contact_obj.create(cr, uid, {
 
100
                    'partner_id': partner_id,
 
101
                    'name': case.name,
 
102
                    'phone': case.phone,
 
103
                    'mobile': case.mobile,
 
104
                    'email': case.email_from,
 
105
                    'fax': case.fax,
 
106
                    'title': case.title,
 
107
                    'function': case.function and case.function.id or False,
 
108
                    'street': case.street,
 
109
                    'street2': case.street2,
 
110
                    'zip': case.zip,
 
111
                    'city': case.city,
 
112
                    'country_id': case.country_id and case.country_id.id or False,
 
113
                    'state_id': case.state_id and case.state_id.id or False,
 
114
                })
 
115
 
 
116
            else:
 
117
                if data['form']['partner_id']:
 
118
                    partner = partner_obj.browse(cr,uid,data['form']['partner_id'])
 
119
                    partner_id = partner.id
 
120
                    contact_id = partner.address and partner.address[0].id
 
121
 
 
122
            partner_ids.append(partner_id)
 
123
            vals = {}
 
124
            if partner_id:
 
125
                vals.update({'partner_id': partner_id})
 
126
            if contact_id:
 
127
                vals.update({'partner_address_id': contact_id})
 
128
            case_obj.write(cr, uid, [case.id], vals)   
 
129
        return partner_ids
 
130
 
 
131
    def _make_partner(self, cr, uid, data, context): 
 
132
        pool = pooler.get_pool(cr.dbname)             
 
133
        partner_ids = self._create_partner(cr, uid, data, context)
 
134
        mod_obj = pool.get('ir.model.data') 
 
135
        result = mod_obj._get_id(cr, uid, 'base', 'view_res_partner_filter')
 
136
        res = mod_obj.read(cr, uid, result, ['res_id'])
 
137
        value = {
 
138
            'domain': "[]",
 
139
            'view_type': 'form',
 
140
            'view_mode': 'form,tree',
 
141
            'res_model': 'res.partner',
 
142
            'res_id': partner_ids and int(partner_ids[0]) or False,
 
143
            'view_id': False,
 
144
            'type': 'ir.actions.act_window',
 
145
            'search_view_id': res['res_id'] 
 
146
        }
 
147
        return value
 
148
 
 
149
    states = {
 
150
        'init': {
 
151
            'actions': [_selectPartner],
 
152
            'result': {'type': 'form', 'arch': case_form, 'fields': case_fields,
 
153
                'state' : [('end', 'Cancel', 'gtk-cancel'),('create_partner', 'Create Partner', 'gtk-go-forward')]}
 
154
        },
 
155
        'create_partner': {
 
156
            'actions': [],
 
157
            'result': {'type': 'form', 'arch': partner_form, 'fields': partner_fields,
 
158
                'state' : [('end', 'Cancel', 'gtk-cancel'),('create', 'Continue', 'gtk-go-forward')]}
 
159
        },
 
160
        'create': {
 
161
            'actions': [],
 
162
            'result': {'type': 'action', 'action': _make_partner, 'state': 'end'}
 
163
        }
 
164
    }
 
165
 
 
166
partner_create('crm.lead.partner_create')
 
167
 
 
168
 
 
169
class lead2opportunity(partner_create):
49
170
 
50
171
    case_form = """<?xml version="1.0"?>
51
172
    <form string="Convert To Opportunity">
75
196
    def _selectopportunity(self, cr, uid, data, context):
76
197
        pool = pooler.get_pool(cr.dbname)
77
198
        case_obj = pool.get('crm.lead')
78
 
        for case in case_obj.browse(cr, uid, data['ids']):
79
 
            if not case.partner_id:
80
 
                return 'create_partner'
81
 
        return {'name': case.name, 'probability': case.probability or 20.0,
82
 
                'planned_revenue':case.planned_revenue, 'partner_id':case.partner_id.id}
 
199
        case = case_obj.browse(cr, uid, data['id'])
 
200
        return {'name': case.name, 'partner_id':case.partner_id and case.partner_id.id or False}
83
201
 
84
202
    def _selectChoice(self, cr, uid, data, context):
85
203
        pool = pooler.get_pool(cr.dbname)
116
234
                'date_deadline': lead.date_deadline,
117
235
                'partner_address_id':lead.partner_address_id.id, 
118
236
                'priority': lead.priority,
119
 
                'date': lead.date,
120
 
                'partner_phone': lead.partner_phone,
121
 
                'canal_id': lead.canal_id,
122
 
                'som': lead.som,
 
237
                'phone': lead.phone,                
123
238
                'email_from': lead.email_from
124
239
            })       
125
240
            
149
264
        return value
150
265
 
151
266
    def _makePartner(self, cr, uid, data, context):
152
 
        pool = pooler.get_pool(cr.dbname)
153
 
        lead_case_obj = pool.get('crm.lead')
154
 
        partner_obj = pool.get('res.partner')
155
 
        contact_obj = pool.get('res.partner.address')
156
 
        if data['form']['action'] == 'create':
157
 
            for case in lead_case_obj.browse(cr, uid, data['ids']):
158
 
                partner_id = partner_obj.search(cr, uid, [('name', '=', case.partner_name or case.name)])
159
 
                if partner_id:
160
 
                    raise wizard.except_wizard(_('Warning !'),_('A partner is already existing with the same name.'))
161
 
                else:
162
 
                    partner_id = partner_obj.create(cr, uid, {
163
 
                        'name': case.partner_name or case.name,
164
 
                        'user_id': case.user_id.id,
165
 
                        'comment': case.description,
166
 
                    })
167
 
                contact_id = contact_obj.create(cr, uid, {
168
 
                    'partner_id': partner_id,
169
 
                    'name': case.partner_name2,
170
 
                    'phone': case.partner_phone,
171
 
                    'mobile': case.partner_mobile,
172
 
                    'email': case.email_from
173
 
                })
174
 
        else:
175
 
            partner = partner_obj.browse(cr,uid,data['form']['partner_id'])
176
 
            partner_id = partner.id
177
 
            contact_id = partner.address and partner.address[0].id 
178
 
        
179
 
        lead_case_obj.write(cr, uid, data['ids'], {
180
 
            'partner_id': partner_id,
181
 
            'partner_address_id': contact_id
182
 
        })
 
267
        partner_ids = self._create_partner(cr, uid, data, context)
183
268
        return {}
184
269
 
185
270
    states = {
188
273
            'result': {'type':'choice','next_state':_selectChoice}
189
274
        },
190
275
        'create_partner': {
191
 
            'actions': [],
192
 
            'result': {'type': 'form', 'arch': partner_form, 'fields': partner_fields,
193
 
                'state' : [('end', 'Cancel', 'gtk-cancel'),('create', 'Continue', 'gtk-go-forward')]}
 
276
            'actions': [partner_create._selectPartner],
 
277
            'result': {'type': 'form', 'arch': partner_create.partner_form, 'fields': partner_create.partner_fields,
 
278
                'state' : [('end', 'Cancel', 'gtk-cancel'),('opportunity', 'Skip', 'gtk-goto-last'), ('create', 'Continue', 'gtk-go-forward')]}
194
279
        },
195
280
        'create': {
196
281
            'actions': [],
209
294
 
210
295
lead2opportunity('crm.lead.opportunity_set')
211
296
 
212
 
class partner_create(wizard.interface):
213
 
 
214
 
    case_form = """<?xml version="1.0"?>
215
 
    <form string="Convert To Partner">
216
 
        <label string="Are you sure you want to create a partner based on this lead ?" colspan="4"/>
217
 
        <label string="You may have to verify that this partner does not exist already." colspan="4"/>
218
 
        <!--field name="close"/-->
219
 
    </form>"""
220
 
 
221
 
    case_fields = {
222
 
        'close': {'type':'boolean', 'string':'Close Lead'}
223
 
    }
224
 
 
225
 
    def _selectPartner(self, cr, uid, data, context):
226
 
        pool = pooler.get_pool(cr.dbname)
227
 
        case_obj = pool.get('crm.lead')
228
 
        for case in case_obj.browse(cr, uid, data['ids']):
229
 
            if case.partner_id:
230
 
                raise wizard.except_wizard(_('Warning !'),
231
 
                    _('A partner is already defined on this lead.'))
232
 
        return {}
233
 
 
234
 
    def _makeOrder(self, cr, uid, data, context):
235
 
        pool = pooler.get_pool(cr.dbname)
236
 
        mod_obj = pool.get('ir.model.data') 
237
 
        result = mod_obj._get_id(cr, uid, 'base', 'view_res_partner_filter')
238
 
        res = mod_obj.read(cr, uid, result, ['res_id'])
239
 
        case_obj = pool.get('crm.lead')
240
 
        partner_obj = pool.get('res.partner')
241
 
        contact_obj = pool.get('res.partner.address')
242
 
        for case in case_obj.browse(cr, uid, data['ids']):
243
 
            partner_id = partner_obj.search(cr, uid, [('name', '=', case.partner_name or case.name)])
244
 
            if partner_id:
245
 
                raise wizard.except_wizard(_('Warning !'),_('A partner is already existing with the same name.'))
246
 
            else:
247
 
                partner_id = partner_obj.create(cr, uid, {
248
 
                    'name': case.partner_name or case.name,
249
 
                    'user_id': case.user_id.id,
250
 
                    'comment': case.description,
251
 
                })
252
 
            contact_id = contact_obj.create(cr, uid, {
253
 
                'partner_id': partner_id,
254
 
                'name': case.partner_name2,
255
 
                'phone': case.partner_phone,
256
 
                'mobile': case.partner_mobile,
257
 
                'email': case.email_from
258
 
            })
259
 
 
260
 
 
261
 
        case_obj.write(cr, uid, data['ids'], {
262
 
            'partner_id': partner_id,
263
 
            'partner_address_id': contact_id
264
 
        })
265
 
        if data['form']['close']:
266
 
            case_obj.case_close(cr, uid, data['ids'])
267
 
 
268
 
        value = {
269
 
            'domain': "[]",
270
 
            'view_type': 'form',
271
 
            'view_mode': 'form,tree',
272
 
            'res_model': 'res.partner',
273
 
            'res_id': int(partner_id),
274
 
            'view_id': False,
275
 
            'type': 'ir.actions.act_window',
276
 
            'search_view_id': res['res_id'] 
277
 
        }
278
 
        return value
279
 
 
280
 
    states = {
281
 
        'init': {
282
 
            'actions': [_selectPartner],
283
 
            'result': {'type': 'form', 'arch': case_form, 'fields': case_fields,
284
 
                'state' : [('end', 'Cancel', 'gtk-cancel'),('confirm', 'Create Partner', 'gtk-go-forward')]}
285
 
        },
286
 
        'confirm': {
287
 
            'actions': [],
288
 
            'result': {'type': 'action', 'action': _makeOrder, 'state': 'end'}
289
 
        }
290
 
    }
291
 
 
292
 
partner_create('crm.lead.partner_create')
293
 
 
294
297
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: