You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

273 lines
12 KiB

from openerp.osv import osv,fields as old_fields
from openerp import api, models, fields, tools
from openerp.tools.safe_eval import safe_eval
from openerp.addons.email_template.email_template import mako_template_env
import copy
from openerp.tools.translate import _
from datetime import date, datetime, timedelta
from openerp.tools import DEFAULT_SERVER_DATE_FORMAT
from openerp.tools import DEFAULT_SERVER_DATETIME_FORMAT
class mail_wall_widgets_widget(models.Model):
_name = 'mail.wall.widgets.widget'
_order = "sequence, id"
_columns = {
'name': old_fields.char('Name', required=True, translate=True),
'type': old_fields.selection(string='Type', selection=[
('list', 'List'),
('funnel', 'Funnel'),
('slice', 'Slice'),
#('', ''),
#('', ''),
#('', ''),
#('', ''),
], help='''
Slice - use "domain" for total and "won_domain" for target
'''),
'description': old_fields.text('Description', translate=True),
'group_ids': old_fields.many2many('res.groups', relation='mail_wall_widgets_widget_group', column1='widget_id', column2='group_id', string='Groups', help="User groups to show widget"),
'model_id': old_fields.many2one('ir.model', string='Model', help='The model object for the field to evaluate'),
'domain': old_fields.char("Filter Domain", help="Domain for filtering records. General rule, not user depending, e.g. [('state', '=', 'done')]. The expression can contain reference to 'user' which is a browse record of the current user if not in batch mode.", required=True),
'limit': old_fields.integer('Limit', help='Limit count of records to show'),
'order': old_fields.char('Order', help='Order of records to show'),
'value_field_id': old_fields.many2one('ir.model.fields',
string='Value field',
help='The field containing the value of record'),
'stage_field_id': old_fields.many2one('ir.model.fields',
string='Stage field',
help='Field to split records in funnel. It can be selection type or many2one (the later should have "sequence" field)'),
#'stage_field_domain': old_fields.many2one('ir.model.fields',
# string='Stage field domain',
# help='(for many2one stage_field_id) Domain to find stage objects'),
'won_domain': old_fields.char('Won domain',
help='Domain to find won objects'),
'field_date_id': old_fields.many2one('ir.model.fields',
string='Date Field',
help='The date to use for the time period evaluated'),
'start_date': old_fields.date('Start Date'),
'end_date': old_fields.date('End Date'), # no start and end = always active
'content': old_fields.char('Line template', help='Mako template to show content'),
'value_field_monetary': old_fields.boolean('Value is monetary'),
'cache': old_fields.boolean('Cache'),
'active': old_fields.boolean('Active'),
'sequence': old_fields.integer('Sequence', help='Sequence number for ordering'),
}
precision = fields.Float('Precision', help='round(Value/precision) * precision. E.g. 12345,333333 will be rounded to 12345,33 for precision=0.01, and to 12000 for precision=1000', default=0.01)
agenda = fields.Boolean('Agenda', help='Split records by date: overdue, today, tomorrow, later')
_defaults = {
'active': True,
'cache': False,
'limit': None,
'order': None,
}
@api.one
def get_data(self, user):
domain = safe_eval(self.domain, {'user': user})
won_domain = safe_eval(self.won_domain or '[]', {'user': user})
field_date_name = self.field_date_id and self.field_date_id.name
if self.start_date and field_date_name:
domain.append((field_date_name, '>=', self.start_date))
if self.end_date and field_date_name:
domain.append((field_date_name, '<=', self.end_date))
res = {
'name': self.name,
'type': self.type,
'model': self.model_id.model,
'domain': str(domain),
'precision': self.precision,
}
obj = self.env[self.model_id.model]
if self.type == 'list':
total_count = obj.search_count(domain)
groups = [{'test': lambda r: True}]
if self.agenda:
today = date.today()
tomorrow = today + timedelta(days=1)
def r2date(r):
d = getattr(r, field_date_name)
d = datetime.strptime(d, self.field_date_id.ttype=='date' and DEFAULT_SERVER_DATE_FORMAT or DEFAULT_SERVER_DATETIME_FORMAT)
d = d.date()
return d
groups = [
{
'label': _('Overdue'),
'class': 'overdue',
'test': lambda r: r2date(r) < today,
'mandatory': False,
},
{
'label': _('Today'),
'class': 'today',
'test': lambda r: r2date(r) == today,
'mandatory': True,
},
{
'label': _('Tomorrow'),
'class': 'tomorrow',
'test': lambda r: r2date(r) == tomorrow,
'mandatory': False,
},
{
'label': _('Later'),
'class': 'later',
'test': lambda r: r2date(r) > tomorrow,
'mandatory': False,
},
]
for g in groups:
g['lines'] = []
res.update({
'more': self.limit and self.limit < total_count,
'total_count': total_count,
'agenda': self.agenda,
'groups': groups,
})
for r in obj.search(domain, limit=self.limit, order=self.order):
mako = mako_template_env.from_string(tools.ustr(self.content))
content = mako.render({'record':r})
r_json = {
'id': r.id,
#'fields': dict( (f,getattr(r,f)) for f in fields),
'display_mode': 'progress',
'state': 'inprogress',
'completeness': 0,
'name': content,
'description': '',
}
if self.value_field_id:
r_json['current'] = getattr(r, self.value_field_id.name)
if self.value_field_monetary:
r_json['monetary'] = 1
for g in groups:
if g['test'](r):
g['lines'].append(r_json)
break
for g in groups:
del g['test']
elif self.type == 'funnel':
stage_ids = [] # [key]
for group in obj.read_group(domain, [], [self.stage_field_id.name]):
key = group[self.stage_field_id.name]
if isinstance(key, (list, tuple)):
key = key[0]
stage_ids.append(key)
stages = [] # [{'name':Name, 'id': key}]
if self.stage_field_id.ttype == 'selection':
d = dict (self.stage_field_id.selection)
stages = [ {'id':id, 'name':d[id]} for id in stage_ids ]
else: # many2one
stage_model = self.stage_field_id.relation
for r in self.env[stage_model].browse(stage_ids):
stages.append({'id': r.id, 'name':r.name_get()[0][1]})
value_field_name = self.value_field_id.name
for stage in stages:
d = copy.copy(domain)
d.append( (self.stage_field_id.name, '=', stage['id']) )
result = obj.read_group(d, [value_field_name], [])
stage['closed_value'] = result and result[0][value_field_name] or 0.0
stage['domain'] = str(d)
# won value
d = domain + won_domain
result = obj.read_group(domain, [value_field_name], [])
won = {'name': _('Won'),
'id':'__won__',
'closed_value': result and result[0][value_field_name] or 0.0
}
stages.append(won)
cur = 0
for stage in reversed(stages):
cur += stage['closed_value']
stage['abs_value'] = cur
total_value = stages[0]['abs_value']
precision = self.precision
for s in stages:
s['rel_value'] = round(100*s['abs_value']/total_value/precision)*precision if total_value else 100
# dummy fields
s['display_mode'] = 'progress'
s['monetary'] = 1
res['stages'] = stages
res['won'] = won
res['conversion_rate'] = stages[-1]['rel_value']
elif self.type == 'slice':
value_field_name = self.value_field_id.name
for f,d in [('total', domain), ('won', won_domain)]:
result = obj.read_group(d, [value_field_name], [])
res[f] = result and result[0][value_field_name] or 0.0
res['domain'] = str(domain)
res['won_domain'] = str(won_domain)
precision = self.precision
total_value = res['total']
res['slice'] = round(100*res['won']/res['total']/precision)*precision if res['total'] else 100
# dummy fields
res['display_mode'] = 'progress'
res['monetary'] = self.value_field_monetary
return res
class mail_wall_widgets_cache(models.Model):
_name = 'mail.wall.widgets.cache'
cache = fields.Text('Cached data')
res_id = fields.Integer('Resource ID')
res_model = fields.Integer('Resource Model')
user_id = fields.Many2one('res.users')
class res_users(models.Model):
_inherit = 'res.users'
@api.v7
def get_serialised_mail_wall_widgets_summary(self, cr, uid, excluded_categories=None, context=None):
return self._get_serialised_mail_wall_widgets_summary(cr, uid, uid, excluded_categories=excluded_categories, context=context)[0]
@api.one
def _get_serialised_mail_wall_widgets_summary(self, excluded_categories=None):
"""
[
{
'id': ...,
'model': ...,
'currency': <res.currency id>,
'data': (depend on model)
},
]
"""
user = self.env.user
res = []
model = 'mail.wall.widgets.widget'
domain = [('group_ids', 'in', user.groups_id.ids), ('active', '=', True)]
for widget in self.env[model].search(domain, order='sequence'):
if widget.cache:
#TODO
continue
res.append({
'model': model,
'id': widget.id,
'currency': user.company_id.currency_id.id,
'data': widget.get_data(user)[0],
})
return res
#def get_challenge_suggestions(self, cr, uid, context=None):
# """Return the list of challenges suggested to the user"""
# challenge_info = []
# challenge_obj = self.pool.get('mail_wall_widgets.challenge')
# challenge_ids = challenge_obj.search(cr, uid, [('invited_user_ids', 'in', uid), ('state', '=', 'inprogress')], context=context)
# for challenge in challenge_obj.browse(cr, uid, challenge_ids, context=context):
# values = {
# 'id': challenge.id,
# 'name': challenge.name,
# 'description': challenge.description,
# }
# challenge_info.append(values)
# return challenge_info