293 lines
12 KiB
Python
293 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo, Flectra. See LICENSE file for full copyright and licensing
|
|
# details.
|
|
|
|
# TODO:
|
|
# Error treatment: exception, request, ... -> send request to user_id
|
|
|
|
from flectra import api, fields, models, _
|
|
from flectra.exceptions import UserError, ValidationError
|
|
|
|
|
|
def _get_document_types(self):
|
|
return [(doc.model.model, doc.name) for doc in self.env[
|
|
'recurring.document'].search([], order='name')]
|
|
|
|
|
|
class RecurringDocument(models.Model):
|
|
_name = "recurring.document"
|
|
_description = "Recurring Document"
|
|
|
|
name = fields.Char(string='Name')
|
|
active = fields.Boolean(
|
|
help="If the active field is set to False, it will allow you to hide "
|
|
"the recurring document without removing it.", default=True)
|
|
model = fields.Many2one('ir.model', string="Object")
|
|
field_ids = fields.One2many('recurring.document.fields',
|
|
'document_id', string='Fields', copy=True)
|
|
|
|
|
|
class RecurringDocumentFields(models.Model):
|
|
_name = "recurring.document.fields"
|
|
_description = "Recurring Document Fields"
|
|
_rec_name = 'field'
|
|
|
|
field = fields.Many2one('ir.model.fields', domain="[('model_id', '=', "
|
|
"parent.model)]")
|
|
value = fields.Selection(
|
|
[('false', 'False'), ('date', 'Current Date')], string='Default Value',
|
|
help="Default value is considered for field when new document is "
|
|
"generated.")
|
|
document_id = fields.Many2one('recurring.document',
|
|
string='Recurring Document',
|
|
ondelete='cascade')
|
|
|
|
|
|
class Recurring(models.Model):
|
|
_name = "recurring"
|
|
_description = "Recurring"
|
|
|
|
@api.model
|
|
def default_get(self, fields):
|
|
res = super(Recurring, self).default_get(fields)
|
|
active_model = self._context.get('active_model')
|
|
active_id = self._context.get('active_id')
|
|
if active_model and active_id:
|
|
record = self.env[active_model].browse(active_id)
|
|
if 'partner_id' in self.env[active_model]._fields:
|
|
res['partner_id'] = record.partner_id.id
|
|
else:
|
|
res['name'] = record.name
|
|
if not res['name']:
|
|
res['name'] = record.number
|
|
return res
|
|
|
|
@api.onchange('partner_id')
|
|
def _onchange_partner_id(self):
|
|
active_model = self._context.get('active_model')
|
|
active_id = self._context.get('active_id')
|
|
if self.partner_id and active_model and active_id:
|
|
record = self.env[active_model].browse(active_id)
|
|
name = record.name
|
|
if not name:
|
|
name = record.number
|
|
if name:
|
|
self.name = name + '-' + self.partner_id.name
|
|
else:
|
|
self.name = self.partner_id.name
|
|
|
|
@api.constrains('partner_id', 'doc_source')
|
|
def _check_partner_id_doc_source(self):
|
|
for record in self:
|
|
if record.partner_id and record.doc_source and 'partner_id' in \
|
|
self.env[record.doc_source._name]._fields and \
|
|
record.doc_source.partner_id != record.partner_id:
|
|
raise ValidationError(_(
|
|
'Error! Source Document should be related to partner %s' %
|
|
record.doc_source.partner_id.name))
|
|
|
|
name = fields.Char(string='Name')
|
|
active = fields.Boolean(
|
|
help="If the active field is set to False, it will allow you to hide "
|
|
"the recurring without removing it.", default=True)
|
|
partner_id = fields.Many2one('res.partner', string='Partner')
|
|
notes = fields.Text(string='Internal Notes')
|
|
user_id = fields.Many2one('res.users', string='User',
|
|
default=lambda self: self.env.user)
|
|
interval_number = fields.Integer(string='Internal Qty', default=1)
|
|
interval_type = fields.Selection(
|
|
[('minutes', 'Minutes'), ('hours', 'Hours'), ('days', 'Days'),
|
|
('weeks', 'Weeks'), ('months', 'Months')], string='Interval Unit',
|
|
default='months')
|
|
exec_init = fields.Integer(string='Number of Documents')
|
|
date_init = fields.Datetime(string='First Date',
|
|
default=fields.Datetime.now)
|
|
state = fields.Selection(
|
|
[('draft', 'Draft'), ('running', 'Running'), ('done', 'Done')],
|
|
string='Status', copy=False, default='draft')
|
|
doc_source = fields.Reference(
|
|
selection=_get_document_types, string='Source Document',
|
|
help="User can choose the source document on which he wants to "
|
|
"create documents")
|
|
doc_lines = fields.One2many('recurring.history',
|
|
'recurring_id', string='Documents created')
|
|
cron_id = fields.Many2one('ir.cron', string='Cron Job',
|
|
help="Scheduler which runs on recurring",
|
|
states={'running': [('readonly', True)],
|
|
'done': [('readonly', True)]})
|
|
note = fields.Text(string='Notes',
|
|
help="Description or Summary of Recurring")
|
|
|
|
@api.model
|
|
def _auto_end(self):
|
|
super(Recurring, self)._auto_end()
|
|
# drop the FK from recurring to ir.cron, as it would cause deadlocks
|
|
# during cron job execution. When model_copy() tries to write() on
|
|
# the recurring,
|
|
# it has to wait for an ExclusiveLock on the cron job record,
|
|
# but the latter is locked by the cron system for the duration of
|
|
# the job!
|
|
# FIXME: the recurring module should be reviewed to simplify the
|
|
# scheduling process
|
|
# and to use a unique cron job for all recurrings, so that it
|
|
# never needs to be updated during its execution.
|
|
self.env.cr.execute("ALTER TABLE %s DROP CONSTRAINT %s" % (
|
|
self._table, '%s_cron_id_fkey' % self._table))
|
|
|
|
@api.multi
|
|
def create_recurring_type(self):
|
|
rec_doc_obj = self.env['recurring.document']
|
|
ir_model_id = self.env['ir.model'].search(
|
|
[('model', '=', self._context.get('active_model', False))])
|
|
rec_doc_id = rec_doc_obj.search([('model', '=', ir_model_id.id)])
|
|
if not rec_doc_id:
|
|
rec_doc_id = rec_doc_obj.create({
|
|
'name': ir_model_id.name,
|
|
'model': ir_model_id.id,
|
|
})
|
|
return rec_doc_id
|
|
|
|
@api.multi
|
|
def btn_recurring(self):
|
|
self.ensure_one()
|
|
rec_doc_id = self.create_recurring_type()
|
|
if rec_doc_id:
|
|
active_model = self._context.get('active_model')
|
|
active_id = self._context.get('active_id')
|
|
if active_id and active_model:
|
|
record = self.env[active_model].browse(active_id)
|
|
self.doc_source = record._name + "," + str(record.id)
|
|
record.recurring_id = self.id
|
|
record.rec_source_id = record.id
|
|
if self._context.get('process') == 'start':
|
|
self.set_process()
|
|
|
|
@api.multi
|
|
def set_process(self):
|
|
for recurring in self:
|
|
model = 'recurring'
|
|
cron_data = {
|
|
'name': recurring.name,
|
|
'interval_number': recurring.interval_number,
|
|
'interval_type': recurring.interval_type,
|
|
'numbercall': recurring.exec_init,
|
|
'nextcall': recurring.date_init,
|
|
'model_id': self.env['ir.model'].search(
|
|
[('model', '=', model)]).id,
|
|
'priority': 6,
|
|
'user_id': recurring.user_id.id,
|
|
'state': 'code',
|
|
'code': 'model._cron_model_copy('+repr([recurring.id])+')',
|
|
}
|
|
cron = self.env['ir.cron'].sudo().create(cron_data)
|
|
recurring.write({'cron_id': cron.id, 'state': 'running'})
|
|
|
|
@api.multi
|
|
def set_recurring_id(self):
|
|
if self.doc_source and 'recurring_id' and 'rec_source_id' in \
|
|
self.env[self.doc_source._name]._fields:
|
|
rec_id = self.env[self.doc_source._name].browse(self.doc_source.id)
|
|
if not rec_id.recurring_id and not rec_id.rec_source_id:
|
|
rec_id.recurring_id = self.id
|
|
rec_id.rec_source_id = self.doc_source.id
|
|
else:
|
|
raise ValidationError(
|
|
_('Document is already recurring'))
|
|
|
|
@api.model
|
|
def create(self, vals):
|
|
if vals.get('doc_source', False) and self.search(
|
|
[('doc_source', '=', vals['doc_source'])]):
|
|
raise ValidationError(
|
|
_('Recurring of the selected Source Document already exist'))
|
|
res = super(Recurring, self).create(vals)
|
|
res.set_recurring_id()
|
|
return res
|
|
|
|
@api.multi
|
|
def write(self, values):
|
|
doc_source_id = False
|
|
if values.get('doc_source', False):
|
|
doc_source_id = self.doc_source
|
|
res = super(Recurring, self).write(values)
|
|
if doc_source_id:
|
|
rec_id = self.env[doc_source_id._name].browse(doc_source_id.id)
|
|
rec_id.recurring_id = False
|
|
self.set_recurring_id()
|
|
return res
|
|
|
|
@api.multi
|
|
def get_recurring(self, model, active_id):
|
|
result = self.env.ref('recurring.action_recurring_form').read()[0]
|
|
record = self.env[model].browse(active_id)
|
|
rec_ids = self.env['recurring'].search(
|
|
[('doc_source', '=', record._name + "," + str(record.id))])
|
|
result['domain'] = [('id', 'in', rec_ids.ids)]
|
|
return result
|
|
|
|
@api.multi
|
|
def get_recurring_documents(self, model, action, recurring_id):
|
|
result = self.env.ref(action).read()[0]
|
|
res_ids = self.env[model].search(
|
|
[('recurring_id', '=', recurring_id.id)])
|
|
result['domain'] = [('id', 'in', res_ids.ids)]
|
|
return result
|
|
|
|
@api.model
|
|
def _cron_model_copy(self, ids):
|
|
self.browse(ids).model_copy()
|
|
|
|
@api.multi
|
|
def model_copy(self):
|
|
for recurring in self.filtered(lambda sub: sub.cron_id):
|
|
if not recurring.doc_source.exists():
|
|
raise UserError(_('Please provide another source '
|
|
'document.\nThis one does not exist!'))
|
|
|
|
default = {}
|
|
documents = self.env['recurring.document'].search(
|
|
[('model.model', '=', recurring.doc_source._name)], limit=1)
|
|
fieldnames = dict((f.field.name, f.value == 'date' and
|
|
fields.Date.today() or False)
|
|
for f in documents.field_ids)
|
|
default.update(fieldnames)
|
|
# if there was only one remaining document to generate
|
|
# the recurring is over and we mark it as being done
|
|
if recurring.cron_id.numbercall == 1:
|
|
recurring.write({'state': 'done'})
|
|
else:
|
|
recurring.write({'state': 'running'})
|
|
copied_doc = recurring.doc_source.copy(default)
|
|
self.env['recurring.history'].create({
|
|
'recurring_id': recurring.id,
|
|
'date': fields.Datetime.now(),
|
|
'document_id': '%s,%s' % (recurring.doc_source._name,
|
|
copied_doc.id)})
|
|
|
|
@api.multi
|
|
def unlink(self):
|
|
if any(self.filtered(lambda s: s.state == "running")):
|
|
raise UserError(_('You cannot delete an active recurring!'))
|
|
return super(Recurring, self).unlink()
|
|
|
|
@api.multi
|
|
def set_done(self):
|
|
self.mapped('cron_id').write({'active': False})
|
|
self.write({'state': 'done'})
|
|
|
|
@api.multi
|
|
def set_draft(self):
|
|
self.write({'state': 'draft'})
|
|
|
|
|
|
class RecurringHistory(models.Model):
|
|
_name = "recurring.history"
|
|
_description = "Recurring history"
|
|
_rec_name = 'date'
|
|
|
|
date = fields.Datetime(string='Date')
|
|
recurring_id = fields.Many2one('recurring', string='Recurring',
|
|
ondelete='cascade')
|
|
document_id = fields.Reference(
|
|
selection=_get_document_types, string='Source Document')
|