← Back to branch summary

~openerp-commiter/openobject-addons/trunk-extra-addons

« back to all changes in this revision

Viewing changes to dm/customer.py

account_indian is a branch of the trunk addons
make account_indian up to date with the trunk-extra-addons

Show diffs side-by-side

added added

removed removed

Lines of Context:
dm/customer.py
 
1
# -*- encoding: utf-8 -*-
 
2
##############################################################################
 
3
#
 
4
#    OpenERP, Open Source Management Solution    
 
5
#    Copyright (C) 2004-2008 Tiny SPRL (<http://tiny.be>). All Rights Reserved
 
6
#    $Id$
 
7
#
 
8
#    This program is free software: you can redistribute it and/or modify
 
9
#    it under the terms of the GNU General Public License as published by
 
10
#    the Free Software Foundation, either version 3 of the License, or
 
11
#    (at your option) any later version.
 
12
#
 
13
#    This program is distributed in the hope that it will be useful,
 
14
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
#    GNU General Public License for more details.
 
17
#
 
18
#    You should have received a copy of the GNU General Public License
 
19
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
20
#
 
21
##############################################################################
 
22
import time
 
23
 
 
24
from osv import fields
 
25
from osv import osv
 
26
import pooler
 
27
import sys
 
28
import datetime
 
29
 
 
30
class dm_order(osv.osv):
 
31
    _name = "dm.order"
 
32
    _columns = {
 
33
        'raw_datas' : fields.char('Raw Datas', size=128),
 
34
        'customer_code' : fields.char('Customer Code',size=64),
 
35
        'title' : fields.char('Title',size=32),
 
36
        'customer_firstname' : fields.char('First Name', size=64),
 
37
        'customer_lastname' : fields.char('Last Name', size=64),
 
38
        'customer_add1' : fields.char('Address1', size=64),
 
39
        'customer_add2' : fields.char('Address2', size=64),
 
40
        'customer_add3' : fields.char('Address3', size=64),
 
41
        'customer_add4' : fields.char('Address4', size=64),
 
42
        'country' : fields.char('Country', size=16),
 
43
        'zip' : fields.char('Zip Code', size=12),
 
44
        'zip_summary' : fields.char('Zip Summary', size=64),
 
45
        'distribution_office' : fields.char('Distribution Office', size=64),
 
46
        'segment_code' : fields.char('Segment Code', size=64),
 
47
        'offer_step_code' : fields.char('Offer Step Code', size=64),
 
48
        'state' : fields.selection([('draft','Draft'),('done','Done')], 'Status', readonly=True),
 
49
    }
 
50
    _defaults = {
 
51
        'state': lambda *a: 'draft',
 
52
    }
 
53
 
 
54
    def set_confirm(self, cr, uid, ids, *args):
 
55
        return True
 
56
 
 
57
    def onchange_rawdatas(self,cr,uid,ids,raw_datas):
 
58
        if not raw_datas:
 
59
            return {}
 
60
        raw_datas = "2;00573G;162220;MR;Shah;Harshit;W Sussex;;25 Oxford Road;;GBR;BN;BN11 1XQ;WORTHING.LU.SX"
 
61
        value = raw_datas.split(';')
 
62
        key = ['datamatrix_type','segment_code','customer_code','title','customer_lastname','customer_firstname','customer_add1','customer_add2','customer_add3','customer_add4','country','zip_summary','zip','distribution_office']
 
63
        value = dict(zip(key,value))
 
64
        return {'value':value}
 
65
 
 
66
dm_order()
 
67
 
 
68
 
 
69
class res_partner(osv.osv):
 
70
    _inherit = "res.partner"
 
71
    _columns = {
 
72
        'language_ids' : fields.many2many('res.lang','dm_customer_langs','lang_id','customer_id','Other Languages'),
 
73
        'prospect_media_ids' : fields.many2many('dm.media','dm_customer_prospect_media','prospect_media_id','customer_id','Prospect for Media'),
 
74
        'client_media_ids' : fields.many2many('dm.media','dm_customer_client_media','client_media_id','customer_id','Client for Media'),
 
75
        'decoy_address' : fields.boolean('Decoy Address', help='A decoy address is an address used to identify unleagal uses of a customers file'),
 
76
        'decoy_owner' : fields.many2one('res.partner','Decoy Address Owner', help='The partner this decoy address belongs to'),
 
77
        'decoy_external_ref' : fields.char('External Reference', size=64, help='The reference of the decoy address for the owner'),
 
78
        'decoy_media_ids': fields.many2many('dm.media','dm_decoy_media_rel','decoy_media_id','customer_id','decoy address for Media'),
 
79
        'decoy_for_campaign': fields.boolean('Used for Campaigns', help='Define if this decoy address can be used with campaigns'),
 
80
        'decoy_for_renting': fields.boolean('Used for File Renting', help='Define if this decoy address can be used with used with customers files renting'),
 
81
    }
 
82
res_partner()
 
83
 
 
84
 
 
85
class dm_customer_order(osv.osv):
 
86
    _name = "dm.customer.order"
 
87
    _inherit = "sale.order"
 
88
    _table = "sale_order"
 
89
    _columns ={
 
90
        'customer_id' : fields.many2one('res.partner', 'Customer', ondelete='cascade'),
 
91
        'segment_id' : fields.many2one('dm.campaign.proposition.segment','Segment'),
 
92
        'offer_step_id' : fields.many2one('dm.offer.step','Offer Step'),
 
93
#        'note' : fields.text('Notes'),
 
94
        'state' : fields.selection([('draft','Draft'),('done','Done')], 'Status', readonly=True),
 
95
    }
 
96
    _defaults = {
 
97
        'picking_policy': lambda *a: 'one',
 
98
#        'state': lambda *a: 'draft',
 
99
    }
 
100
    def set_confirm(self, cr, uid, ids, *args):
 
101
        self.write(cr, uid, ids, {'state': 'done'})
 
102
        return True
 
103
 
 
104
dm_customer_order()
 
105
 
 
106
class dm_customer_gender(osv.osv):
 
107
    _name = "dm.customer.gender"
 
108
    def _customer_gender_code(self, cr, uid, ids, name, args, context={}):
 
109
        result ={}
 
110
        for id in ids:
 
111
            code=""
 
112
            cust_gender = self.browse(cr,uid,[id])[0]
 
113
            if cust_gender.lang_id:
 
114
                if not cust_gender.from_gender_id:
 
115
                    code='_'.join([cust_gender.lang_id.code, cust_gender.to_gender_id.name])
 
116
                else:
 
117
                    code='_'.join([cust_gender.lang_id.code, 'from', cust_gender.from_gender_id.name, 'to', cust_gender.to_gender_id.name])
 
118
            else:
 
119
                if not cust_gender.from_gender_id:
 
120
                    code=cust_gender.to_gender_id.name
 
121
                else:
 
122
                    code='_'.join(['from', cust_gender.from_gender_id.name, 'to', cust_gender.to_gender_id.name])
 
123
            result[id]=code
 
124
        return result
 
125
 
 
126
    _columns = {
 
127
        'name' : fields.char('Name', size=16),
 
128
        'code' : fields.function(_customer_gender_code,string='Code',type='char',method=True,readonly=True),
 
129
        'from_gender_id' : fields.many2one('res.partner.title', 'From Gender', domain="[('domain','=','contact')]"),
 
130
        'to_gender_id' : fields.many2one('res.partner.title', 'To Gender', required=True, domain="[('domain','=','contact')]"),
 
131
        'lang_id' : fields.many2one('res.lang', 'Language'),
 
132
        'description' : fields.text('Description'),
 
133
    }
 
134
dm_customer_gender()
 
135
 
 
136
class dm_workitem(osv.osv):
 
137
    _name = "dm.workitem"
 
138
    _description = "workitem"
 
139
 
 
140
    _SOURCES = [('address_id','Partner Address')]
 
141
 
 
142
    _columns = {
 
143
        'step_id' : fields.many2one('dm.offer.step', 'Offer Step', select="1", ondelete="cascade"),
 
144
        'segment_id' : fields.many2one('dm.campaign.proposition.segment', 'Segments', select="1", ondelete="cascade"),
 
145
        'address_id' : fields.many2one('res.partner.address', 'Customer Address', select="1", ondelete="cascade"),
 
146
        'action_time' : fields.datetime('Action Time'),
 
147
        'source' : fields.selection(_SOURCES, 'Source', required=True),
 
148
        'error_msg' : fields.text('Error Message'),
 
149
        'state' : fields.selection([('pending','Pending'),('error','Error'),('cancel','Cancel'),('done','Done')], 'Status'),
 
150
    }
 
151
    _defaults = {
 
152
        'source': lambda *a: 'address_id',
 
153
        'state': lambda *a: 'pending',
 
154
    }
 
155
 
 
156
    def run(self, cr, uid, wi, context={}):
 
157
        print "Calling run"
 
158
        context['active_id'] = wi.id
 
159
        done = False
 
160
        try:
 
161
            server_obj = self.pool.get('ir.actions.server')
 
162
            print "Calling run for : ",wi.step_id.action_id.server_action_id.name
 
163
            res = server_obj.run(cr, uid, [wi.step_id.action_id.server_action_id.id], context)
 
164
            self.write(cr, uid, [wi.id], {'state': 'done','error_msg':""})
 
165
            done = True
 
166
        except :
 
167
            self.write(cr, uid, [wi.id], {'state': 'error','error_msg':sys.exc_info()})
 
168
        if done:
 
169
            """ Create next auto workitems """
 
170
            for tr in wi.step_id.outgoing_transition_ids:
 
171
                if tr.condition_id.type == "auto":
 
172
                    print "Creating auto workitem"
 
173
                    print "Delay : ",tr.delay
 
174
                    print "Delay Type: ",tr.delay_type
 
175
                    wi_action_time = datetime.datetime.strptime(wi.action_time, '%Y-%m-%d  %H:%M:%S')
 
176
                    if tr.delay_type == 'minute':
 
177
                        next_action_time = wi_action_time + datetime.timedelta(minutes=tr.delay)
 
178
                    elif tr.delay_type == 'hour':
 
179
                        next_action_time = wi_action_time + datetime.timedelta(hours=tr.delay)
 
180
                    elif tr.delay_type == 'day':
 
181
                        next_action_time = wi_action_time + datetime.timedelta(days=tr.delay)
 
182
                    elif tr.delay_type == 'week':
 
183
                        next_action_time = wi_action_time + datetime.timedelta(weeks=tr.delay)
 
184
                    elif tr.delay_type == 'month':
 
185
                        next_action_time = wi_action_time + datetime.timedelta(months=tr.delay)
 
186
 
 
187
                    print "Next action date : ",next_action_time
 
188
 
 
189
                    aw_id = self.copy(cr, uid, wi.id, {'step_id':tr.step_to_id.id, 'action_time':next_action_time})
 
190
                    print "auto wi : ",aw_id
 
191
 
 
192
        return True
 
193
 
 
194
    def __init__(self, *args):
 
195
        self.is_running = False
 
196
        return super(dm_workitem, self).__init__(*args)
 
197
 
 
198
    def check_all(self, cr, uid, context={}):
 
199
        print "Calling check all"
 
200
        if not self.is_running:
 
201
            self.is_running = True
 
202
            ids = self.search(cr, uid, [('state','=','pending'),
 
203
                ('action_time','<=',time.strftime('%Y-%m-%d %H:%M:%S'))])
 
204
            print "WI to process : ",ids
 
205
            for wi in self.browse(cr, uid, ids, context=context):
 
206
                self.run(cr, uid, wi, context=context)
 
207
            self.is_running = False
 
208
        return True
 
209
dm_workitem()
 
210
 
 
211
class dm_customer_segmentation(osv.osv):
 
212
    _name = "dm.customer.segmentation"
 
213
    _description = "Segmentation"
 
214
 
 
215
    _columns = {
 
216
        'name' : fields.char('Name', size=64, required=True),
 
217
        'code' : fields.char('Code', size=32, required=True),
 
218
        'notes' : fields.text('Description'),
 
219
        'sql_query' : fields.text('SQL Query'),
 
220
        'customer_text_criteria_ids' : fields.one2many('dm.customer.text_criteria', 'segmentation_id', 'Customers Textual Criteria'),
 
221
        'customer_numeric_criteria_ids' : fields.one2many('dm.customer.numeric_criteria', 'segmentation_id', 'Customers Numeric Criteria'),
 
222
        'customer_boolean_criteria_ids' : fields.one2many('dm.customer.boolean_criteria', 'segmentation_id', 'Customers Boolean Criteria'),
 
223
        'customer_date_criteria_ids' : fields.one2many('dm.customer.date_criteria', 'segmentation_id', 'Customers Date Criteria'),
 
224
        'order_text_criteria_ids' : fields.one2many('dm.customer.order.text_criteria', 'segmentation_id', 'Customers Order Textual Criteria'),
 
225
        'order_numeric_criteria_ids' : fields.one2many('dm.customer.order.numeric_criteria', 'segmentation_id', 'Customers Order Numeric Criteria'),
 
226
        'order_boolean_criteria_ids' : fields.one2many('dm.customer.order.boolean_criteria', 'segmentation_id', 'Customers Order Boolean Criteria'),
 
227
        'order_date_criteria_ids' : fields.one2many('dm.customer.order.date_criteria', 'segmentation_id', 'Customers Order Date Criteria'),
 
228
    }
 
229
 
 
230
    def set_customer_criteria(self, cr, uid, id, context={}):
 
231
        criteria=[]
 
232
        browse_id = self.browse(cr, uid, id)
 
233
        if browse_id.customer_text_criteria_ids:
 
234
            for i in browse_id.customer_text_criteria_ids:
 
235
                criteria.append("p.%s %s '%s'"%(i.field_id.name, i.operator, "%"+i.value+"%"))
 
236
        if browse_id.customer_numeric_criteria_ids:
 
237
            for i in browse_id.customer_numeric_criteria_ids:
 
238
                criteria.append("p.%s %s %f"%(i.field_id.name, i.operator, i.value))
 
239
        if browse_id.customer_boolean_criteria_ids:
 
240
            for i in browse_id.customer_boolean_criteria_ids:
 
241
                criteria.append("p.%s %s %s"%(i.field_id.name, i.operator, i.value))
 
242
        if browse_id.customer_date_criteria_ids:
 
243
            for i in browse_id.customer_date_criteria_ids:
 
244
                criteria.append("p.%s %s '%s'"%(i.field_id.name, i.operator, i.value))
 
245
        if browse_id.order_text_criteria_ids:
 
246
            for i in browse_id.order_text_criteria_ids:
 
247
                criteria.append("s.%s %s '%s'"%(i.field_id.name, i.operator, "%"+i.value+"%"))
 
248
        if browse_id.order_numeric_criteria_ids:
 
249
            for i in browse_id.order_numeric_criteria_ids:
 
250
                criteria.append("s.%s %s %f"%(i.field_id.name, i.operator, i.value))
 
251
        if browse_id.order_boolean_criteria_ids:
 
252
            for i in browse_id.order_boolean_criteria_ids:
 
253
                criteria.append("s.%s %s %s"%(i.field_id.name, i.operator, i.value))
 
254
        if browse_id.order_date_criteria_ids:
 
255
            for i in browse_id.order_date_criteria_ids:
 
256
                criteria.append("s.%s %s '%s'"%(i.field_id.name, i.operator, i.value))
 
257
 
 
258
        if criteria:
 
259
            sql_query = ("""select distinct p.name \nfrom res_partner p, sale_order s\nwhere p.id = s.customer_id and %s\n""" % (' and '.join(criteria))).replace('isnot','is not')
 
260
        else:
 
261
            sql_query = """select distinct p.name \nfrom res_partner p, sale_order s\nwhere p.id = s.customer_id"""
 
262
        return super(dm_customer_segmentation,self).write(cr, uid, id, {'sql_query':sql_query})
 
263
 
 
264
    def create(self,cr,uid,vals,context={}):
 
265
        id = super(dm_customer_segmentation,self).create(cr,uid,vals,context)
 
266
        self.set_customer_criteria(cr, uid, id)
 
267
        return id
 
268
 
 
269
    def write(self, cr, uid, ids, vals, context=None):
 
270
        id = super(dm_customer_segmentation,self).write(cr, uid, ids, vals, context)
 
271
        for i in ids:
 
272
            self.set_customer_criteria(cr, uid, i)
 
273
        return id
 
274
 
 
275
dm_customer_segmentation()
 
276
 
 
277
TEXT_OPERATORS = [
 
278
    ('like','like'),
 
279
    ('ilike','ilike'),
 
280
]
 
281
 
 
282
NUMERIC_OPERATORS = [
 
283
    ('=','equals'),
 
284
    ('<','smaller then'),
 
285
    ('>','bigger then'),
 
286
]
 
287
 
 
288
BOOL_OPERATORS = [
 
289
    ('is','is'),
 
290
    ('isnot','is not'),
 
291
]
 
292
 
 
293
DATE_OPERATORS = [
 
294
    ('=','equals'),
 
295
    ('<','before'),
 
296
    ('>','after'),
 
297
]
 
298
 
 
299
class dm_customer_text_criteria(osv.osv):
 
300
    _name = "dm.customer.text_criteria"
 
301
    _description = "Customer Segmentation Textual Criteria"
 
302
    _rec_name = "segmentation_id"
 
303
 
 
304
    _columns = {
 
305
        'segmentation_id' : fields.many2one('dm.customer.segmentation', 'Segmentation'),
 
306
        'field_id' : fields.many2one('ir.model.fields','Customers Field',
 
307
               domain=[('model_id.model','=','res.partner'),
 
308
               ('ttype','like','char')],
 
309
               context={'model':'res.partner'}),
 
310
        'operator' : fields.selection(TEXT_OPERATORS, 'Operator', size=32),
 
311
        'value' : fields.char('Value', size=128),
 
312
    }
 
313
dm_customer_text_criteria()
 
314
 
 
315
class dm_customer_numeric_criteria(osv.osv):
 
316
    _name = "dm.customer.numeric_criteria"
 
317
    _description = "Customer Segmentation Numeric Criteria"
 
318
    _rec_name = "segmentation_id"
 
319
 
 
320
    _columns = {
 
321
        'segmentation_id' : fields.many2one('dm.customer.segmentation', 'Segmentation'),
 
322
        'field_id' : fields.many2one('ir.model.fields','Customers Field',
 
323
               domain=[('model_id.model','=','res.partner'),
 
324
               (('ttype','like','integer') or ('ttype','like','float'))],
 
325
               context={'model':'res.partner'}),
 
326
        'operator' : fields.selection(NUMERIC_OPERATORS, 'Operator', size=32),
 
327
        'value' : fields.float('Value', digits=(16,2)),
 
328
    }
 
329
dm_customer_numeric_criteria()
 
330
 
 
331
class dm_customer_boolean_criteria(osv.osv):
 
332
    _name = "dm.customer.boolean_criteria"
 
333
    _description = "Customer Segmentation Boolean Criteria"
 
334
    _rec_name = "segmentation_id"
 
335
 
 
336
    _columns = {
 
337
        'segmentation_id' : fields.many2one('dm.customer.segmentation', 'Segmentation'),
 
338
        'field_id' : fields.many2one('ir.model.fields','Customers Field',
 
339
               domain=[('model_id.model','=','res.partner'),
 
340
               ('ttype','like','boolean')],
 
341
               context={'model':'res.partner'}),
 
342
        'operator' : fields.selection(BOOL_OPERATORS, 'Operator', size=32),
 
343
        'value' : fields.selection([('true','True'),('false','False')],'Value'),
 
344
    }
 
345
dm_customer_boolean_criteria()
 
346
 
 
347
class dm_customer_date_criteria(osv.osv):
 
348
    _name = "dm.customer.date_criteria"
 
349
    _description = "Customer Segmentation Date Criteria"
 
350
    _rec_name = "segmentation_id"
 
351
 
 
352
    _columns = {
 
353
        'segmentation_id' : fields.many2one('dm.customer.segmentation', 'Segmentation'),
 
354
        'field_id' : fields.many2one('ir.model.fields','Customers Field',
 
355
               domain=[('model_id.model','=','res.partner'),
 
356
               (('ttype','like','date') or ('ttype','like','datetime'))],
 
357
               context={'model':'res.partner'}),
 
358
        'operator' : fields.selection(DATE_OPERATORS, 'Operator', size=32),
 
359
        'value' : fields.date('Date'),
 
360
    }
 
361
dm_customer_date_criteria()
 
362
 
 
363
class dm_customer_order_text_criteria(osv.osv):
 
364
    _name = "dm.customer.order.text_criteria"
 
365
    _description = "Customer Order Segmentation Textual Criteria"
 
366
    _rec_name = "segmentation_id"
 
367
 
 
368
    _columns = {
 
369
        'segmentation_id' : fields.many2one('dm.customer.segmentation', 'Segmentation'),
 
370
        'field_id' : fields.many2one('ir.model.fields','Customers Field',
 
371
               domain=[('model_id.model','=','dm.customer.order'),
 
372
               ('ttype','like','char')],
 
373
               context={'model':'dm.customer.order'}),
 
374
        'operator' : fields.selection(TEXT_OPERATORS, 'Operator', size=32),
 
375
        'value' : fields.char('Value', size=128),
 
376
    }
 
377
dm_customer_order_text_criteria()
 
378
 
 
379
class dm_customer_order_numeric_criteria(osv.osv):
 
380
    _name = "dm.customer.order.numeric_criteria"
 
381
    _description = "Customer Order Segmentation Numeric Criteria"
 
382
    _rec_name = "segmentation_id"
 
383
 
 
384
    _columns = {
 
385
        'segmentation_id' : fields.many2one('dm.customer.segmentation', 'Segmentation'),
 
386
        'field_id' : fields.many2one('ir.model.fields','Customers Field',
 
387
               domain=[('model_id.model','=','dm.customer.order'),
 
388
               (('ttype','like','integer') or ('ttype','like','float'))],
 
389
               context={'model':'dm.customer.order'}),
 
390
        'operator' : fields.selection(NUMERIC_OPERATORS, 'Operator', size=32),
 
391
        'value' : fields.float('Value', digits=(16,2)),
 
392
    }
 
393
dm_customer_order_numeric_criteria()
 
394
 
 
395
class dm_customer_order_boolean_criteria(osv.osv):
 
396
    _name = "dm.customer.order.boolean_criteria"
 
397
    _description = "Customer Order Segmentation Boolean Criteria"
 
398
    _rec_name = "segmentation_id"
 
399
 
 
400
    _columns = {
 
401
        'segmentation_id' : fields.many2one('dm.customer.segmentation', 'Segmentation'),
 
402
        'field_id' : fields.many2one('ir.model.fields','Customers Field',
 
403
               domain=[('model_id.model','=','dm.customer.order'),
 
404
               ('ttype','like','boolean')],
 
405
               context={'model':'dm.customer.order'}),
 
406
        'operator' : fields.selection(BOOL_OPERATORS, 'Operator', size=32),
 
407
        'value' : fields.selection([('true','True'),('false','False')],'Value'),
 
408
    }
 
409
dm_customer_order_boolean_criteria()
 
410
 
 
411
class dm_customer_order_date_criteria(osv.osv):
 
412
    _name = "dm.customer.order.date_criteria"
 
413
    _description = "Customer Order Segmentation Date Criteria"
 
414
    _rec_name = "segmentation_id"
 
415
 
 
416
    _columns = {
 
417
        'segmentation_id' : fields.many2one('dm.customer.segmentation', 'Segmentation'),
 
418
        'field_id' : fields.many2one('ir.model.fields','Customers Field',
 
419
               domain=[('model_id.model','=','dm.customer.order'),
 
420
               (('ttype','like','date') or ('ttype','like','datetime'))],
 
421
               context={'model':'dm.customer.order'}),
 
422
        'operator' : fields.selection(DATE_OPERATORS, 'Operator', size=32),
 
423
        'value' : fields.date('Date'),
 
424
    }
 
425
dm_customer_order_date_criteria()
 
426
 
 
427
class dm_offer_history(osv.osv):
 
428
    _name = "dm.offer.history"
 
429
    _order = 'date'
 
430
    _columns = {
 
431
        'offer_id' : fields.many2one('dm.offer', 'Offer', required=True, ondelete="cascade"),
 
432
        'date' : fields.date('Drop Date'),
 
433
        'campaign_id' : fields.many2one('dm.campaign','Name', ondelete="cascade"),
 
434
        'code' : fields.char('Code', size=16),
 
435
        'responsible_id' : fields.many2one('res.users','Responsible'),
 
436
    }
 
437
dm_offer_history()