300 lines
9.5 KiB
Python
300 lines
9.5 KiB
Python
#This file is part of Tryton. The COPYRIGHT file at the top level of
|
|
#this repository contains the full copyright notices and license terms.
|
|
from __future__ import with_statement
|
|
from trytond.model import ModelView, ModelSQL, fields
|
|
from trytond.wizard import Wizard
|
|
from trytond.backend import TableHandler
|
|
from trytond.pyson import Equal, Eval, Not, Get, Or, And, Bool
|
|
from trytond.transaction import Transaction
|
|
|
|
STATES = {
|
|
'readonly': Equal(Eval('state'), 'close'),
|
|
}
|
|
DEPENDS = ['state']
|
|
|
|
_ICONS = {
|
|
'open': 'tryton-open',
|
|
'close': 'tryton-readonly',
|
|
}
|
|
|
|
|
|
class Type(ModelSQL, ModelView):
|
|
'Journal Type'
|
|
_name = 'account.journal.type'
|
|
_description = __doc__
|
|
name = fields.Char('Name', size=None, required=True, translate=True)
|
|
code = fields.Char('Code', size=None, required=True)
|
|
|
|
def __init__(self):
|
|
super(Type, self).__init__()
|
|
self._sql_constraints += [
|
|
('code_uniq', 'UNIQUE(code)', 'The code must be unique!'),
|
|
]
|
|
self._order.insert(0, ('code', 'ASC'))
|
|
|
|
Type()
|
|
|
|
|
|
class View(ModelSQL, ModelView):
|
|
'Journal View'
|
|
_name = 'account.journal.view'
|
|
_description = __doc__
|
|
name = fields.Char('Name', size=None, required=True)
|
|
columns = fields.One2Many('account.journal.view.column', 'view', 'Columns')
|
|
|
|
def __init__(self):
|
|
super(View, self).__init__()
|
|
self._order.insert(0, ('name', 'ASC'))
|
|
|
|
View()
|
|
|
|
|
|
class Column(ModelSQL, ModelView):
|
|
'Journal View Column'
|
|
_name = 'account.journal.view.column'
|
|
_description = __doc__
|
|
name = fields.Char('Name', size=None, required=True)
|
|
field = fields.Many2One('ir.model.field', 'Field', required=True,
|
|
domain=[('model.model', '=', 'account.move.line')])
|
|
view = fields.Many2One('account.journal.view', 'View', select=1)
|
|
sequence = fields.Integer('Sequence', select=2)
|
|
required = fields.Boolean('Required')
|
|
readonly = fields.Boolean('Readonly')
|
|
|
|
def __init__(self):
|
|
super(Column, self).__init__()
|
|
self._order.insert(0, ('sequence', 'ASC'))
|
|
|
|
def default_required(self):
|
|
return False
|
|
|
|
def default_readonly(self):
|
|
return False
|
|
|
|
Column()
|
|
|
|
|
|
class Journal(ModelSQL, ModelView):
|
|
'Journal'
|
|
_name = 'account.journal'
|
|
_description = __doc__
|
|
|
|
name = fields.Char('Name', size=None, required=True, translate=True)
|
|
code = fields.Char('Code', size=None)
|
|
active = fields.Boolean('Active', select=2)
|
|
type = fields.Selection('get_types', 'Type', required=True)
|
|
view = fields.Many2One('account.journal.view', 'View')
|
|
centralised = fields.Boolean('Centralised counterpart')
|
|
update_posted = fields.Boolean('Allow cancelling moves')
|
|
sequence = fields.Property(fields.Many2One('ir.sequence', 'Sequence',
|
|
domain=[('code', '=', 'account.journal')],
|
|
context={'code': 'account.journal'},
|
|
states={
|
|
'required': Bool(Get(Eval('context', {}), 'company', 0)),
|
|
}))
|
|
credit_account = fields.Property(fields.Many2One('account.account',
|
|
'Default Credit Account', domain=[
|
|
('kind', '!=', 'view'),
|
|
('company', '=', Get(Eval('context', {}), 'company', 0)),
|
|
],
|
|
states={
|
|
'required': And(Or(Bool(Eval('centralised')),
|
|
Equal(Eval('type'), 'cash')),
|
|
Bool(Get(Eval('context', {}), 'company', 0))),
|
|
'invisible': Not(Bool(Get(Eval('context', {}), 'company', 0))),
|
|
}, depends=['type', 'centralised']))
|
|
debit_account = fields.Property(fields.Many2One('account.account',
|
|
'Default Debit Account', domain=[
|
|
('kind', '!=', 'view'),
|
|
('company', '=', Get(Eval('context', {}), 'company', 0)),
|
|
],
|
|
states={
|
|
'required': And(Or(Bool(Eval('centralised')),
|
|
Equal(Eval('type'), 'cash')),
|
|
Bool(Get(Eval('context', {}), 'company', 0))),
|
|
'invisible': Not(Bool(Get(Eval('context', {}), 'company', 0))),
|
|
}, depends=['type', 'centralised']))
|
|
|
|
def __init__(self):
|
|
super(Journal, self).__init__()
|
|
self._order.insert(0, ('name', 'ASC'))
|
|
|
|
def init(self, module_name):
|
|
super(Journal, self).init(module_name)
|
|
cursor = Transaction().cursor
|
|
table = TableHandler(cursor, self, module_name)
|
|
|
|
# Migration from 1.0 sequence Many2One change into Property
|
|
if table.column_exist('sequence'):
|
|
property_obj = self.pool.get('ir.property')
|
|
cursor.execute('SELECT id, sequence FROM "' + self._table +'"')
|
|
with Transaction().set_user(0):
|
|
for journal_id, sequence_id in cursor.fetchall():
|
|
property_obj.set('sequence', self._name,
|
|
journal_id, (sequence_id and
|
|
'ir.sequence,' + str(sequence_id) or False))
|
|
table.drop_column('sequence', exception=True)
|
|
|
|
def default_active(self):
|
|
return True
|
|
|
|
def default_centralised(self):
|
|
return False
|
|
|
|
def default_update_posted(self):
|
|
return False
|
|
|
|
def default_sequence(self):
|
|
return False
|
|
|
|
def get_types(self):
|
|
type_obj = self.pool.get('account.journal.type')
|
|
type_ids = type_obj.search([])
|
|
types = type_obj.browse(type_ids)
|
|
return [(x.code, x.name) for x in types]
|
|
|
|
def search_rec_name(self, name, clause):
|
|
ids = self.search([
|
|
('code',) + clause[1:],
|
|
], limit=1, order=[])
|
|
if ids:
|
|
return [('code',) + clause[1:]]
|
|
return [(self._rec_name,) + clause[1:]]
|
|
|
|
Journal()
|
|
|
|
|
|
class Period(ModelSQL, ModelView):
|
|
'Journal - Period'
|
|
_name = 'account.journal.period'
|
|
_description = __doc__
|
|
|
|
name = fields.Char('Name', size=None, required=True)
|
|
journal = fields.Many2One('account.journal', 'Journal', required=True,
|
|
ondelete='CASCADE', states=STATES, depends=DEPENDS)
|
|
period = fields.Many2One('account.period', 'Period', required=True,
|
|
ondelete='CASCADE', states=STATES, depends=DEPENDS)
|
|
icon = fields.Function(fields.Char('Icon'), 'get_icon')
|
|
active = fields.Boolean('Active', select=2, states=STATES, depends=DEPENDS)
|
|
state = fields.Selection([
|
|
('open', 'Open'),
|
|
('close', 'Close'),
|
|
], 'State', readonly=True, required=True)
|
|
|
|
def __init__(self):
|
|
super(Period, self).__init__()
|
|
self._sql_constraints += [
|
|
('journal_period_uniq', 'UNIQUE(journal, period)',
|
|
'You can only open one journal per period!'),
|
|
]
|
|
self._order.insert(0, ('name', 'ASC'))
|
|
self._error_messages.update({
|
|
'modify_del_journal_period': 'You can not modify/delete ' \
|
|
'a journal - period with moves!',
|
|
'create_journal_period': 'You can not create ' \
|
|
'a journal - period on a closed period!',
|
|
'open_journal_period': 'You can not open ' \
|
|
'a journal - period from a closed period!',
|
|
})
|
|
|
|
def default_active(self):
|
|
return True
|
|
|
|
def default_state(self):
|
|
return 'open'
|
|
|
|
def get_icon(self, ids, name):
|
|
res = {}
|
|
for period in self.browse(ids):
|
|
res[period.id] = _ICONS.get(period.state, '')
|
|
return res
|
|
|
|
def _check(self, ids):
|
|
move_obj = self.pool.get('account.move')
|
|
for period in self.browse(ids):
|
|
move_ids = move_obj.search([
|
|
('journal', '=', period.journal.id),
|
|
('period', '=', period.period.id),
|
|
], limit=1)
|
|
if move_ids:
|
|
self.raise_user_error('modify_del_journal_period')
|
|
return
|
|
|
|
def create(self, vals):
|
|
period_obj = self.pool.get('account.period')
|
|
if vals.get('period'):
|
|
period = period_obj.browse(vals['period'])
|
|
if period.state == 'close':
|
|
self.raise_user_error('create_journal_period')
|
|
return super(Period, self).create(vals)
|
|
|
|
def write(self, ids, vals):
|
|
if vals != {'state': 'close'} \
|
|
and vals != {'state': 'open'}:
|
|
self._check(ids)
|
|
if vals.get('state') == 'open':
|
|
for journal_period in self.browse(ids):
|
|
if journal_period.period.state == 'close':
|
|
self.raise_user_error('open_journal_period')
|
|
return super(Period, self).write(ids, vals)
|
|
|
|
def delete(self, ids):
|
|
self._check(ids)
|
|
return super(Period, self).delete(ids)
|
|
|
|
def close(self, ids):
|
|
'''
|
|
Close journal - period
|
|
|
|
:param ids: the journal - period ids
|
|
'''
|
|
self.write(ids, {
|
|
'state': 'close',
|
|
})
|
|
|
|
Period()
|
|
|
|
|
|
class ClosePeriod(Wizard):
|
|
'Close Journal - Period'
|
|
_name = 'account.journal.close_period'
|
|
states = {
|
|
'init': {
|
|
'actions': ['_close'],
|
|
'result': {
|
|
'type': 'state',
|
|
'state': 'end',
|
|
},
|
|
},
|
|
}
|
|
|
|
def _close(self, data):
|
|
journal_period_obj = self.pool.get('account.journal.period')
|
|
journal_period_obj.close(data['ids'])
|
|
return {}
|
|
|
|
ClosePeriod()
|
|
|
|
|
|
class ReOpenPeriod(Wizard):
|
|
'Re-Open Journal - Period'
|
|
_name = 'account.journal.reopen_period'
|
|
states = {
|
|
'init': {
|
|
'actions': ['_reopen'],
|
|
'result': {
|
|
'type': 'state',
|
|
'state': 'end',
|
|
},
|
|
},
|
|
}
|
|
|
|
def _reopen(self, data):
|
|
journal_period_obj = self.pool.get('account.journal.period')
|
|
journal_period_obj.write(data['ids'], {
|
|
'state': 'open',
|
|
})
|
|
return {}
|
|
|
|
ReOpenPeriod()
|