437 lines
16 KiB
Python
437 lines
16 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 decimal import Decimal
|
|
|
|
from sql import Null
|
|
from sql.conditionals import Case
|
|
from sql.aggregate import Sum
|
|
|
|
from trytond.model import ModelView, ModelSQL, fields, Unique
|
|
from trytond.wizard import Wizard, StateTransition, StateView, StateAction
|
|
from trytond.wizard import Button
|
|
from trytond import backend
|
|
from trytond.pyson import Eval, Bool, PYSONEncoder
|
|
from trytond.transaction import Transaction
|
|
from trytond.pool import Pool
|
|
from trytond.tools import reduce_ids, grouped_slice
|
|
|
|
__all__ = ['JournalType', 'JournalView', 'JournalViewColumn', 'Journal',
|
|
'OpenJournalCash', 'OpenJournalCashStart',
|
|
'JournalPeriod', 'CloseJournalPeriod', 'ReOpenJournalPeriod']
|
|
|
|
STATES = {
|
|
'readonly': Eval('state') == 'close',
|
|
}
|
|
DEPENDS = ['state']
|
|
|
|
_ICONS = {
|
|
'open': 'tryton-open',
|
|
'close': 'tryton-readonly',
|
|
}
|
|
|
|
|
|
class JournalType(ModelSQL, ModelView):
|
|
'Journal Type'
|
|
__name__ = 'account.journal.type'
|
|
name = fields.Char('Name', size=None, required=True, translate=True)
|
|
code = fields.Char('Code', size=None, required=True)
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(JournalType, cls).__setup__()
|
|
t = cls.__table__()
|
|
cls._sql_constraints += [
|
|
('code_uniq', Unique(t, t.code), 'The code must be unique.'),
|
|
]
|
|
cls._order.insert(0, ('code', 'ASC'))
|
|
|
|
|
|
class JournalView(ModelSQL, ModelView):
|
|
'Journal View'
|
|
__name__ = 'account.journal.view'
|
|
name = fields.Char('Name', size=None, required=True)
|
|
columns = fields.One2Many('account.journal.view.column', 'view', 'Columns')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(JournalView, cls).__setup__()
|
|
cls._order.insert(0, ('name', 'ASC'))
|
|
|
|
|
|
class JournalViewColumn(ModelSQL, ModelView):
|
|
'Journal View Column'
|
|
__name__ = 'account.journal.view.column'
|
|
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=True)
|
|
sequence = fields.Integer('Sequence', select=True)
|
|
required = fields.Boolean('Required')
|
|
readonly = fields.Boolean('Readonly')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(JournalViewColumn, cls).__setup__()
|
|
cls._order.insert(0, ('sequence', 'ASC'))
|
|
|
|
@classmethod
|
|
def __register__(cls, module_name):
|
|
TableHandler = backend.get('TableHandler')
|
|
cursor = Transaction().cursor
|
|
table = TableHandler(cursor, cls, module_name)
|
|
|
|
super(JournalViewColumn, cls).__register__(module_name)
|
|
|
|
# Migration from 2.4: drop required on sequence
|
|
table.not_null_action('sequence', action='remove')
|
|
|
|
@staticmethod
|
|
def order_sequence(tables):
|
|
table, _ = tables[None]
|
|
return [Case((table.sequence == Null, 0), else_=1), table.sequence]
|
|
|
|
@staticmethod
|
|
def default_required():
|
|
return False
|
|
|
|
@staticmethod
|
|
def default_readonly():
|
|
return False
|
|
|
|
|
|
class Journal(ModelSQL, ModelView):
|
|
'Journal'
|
|
__name__ = 'account.journal'
|
|
name = fields.Char('Name', size=None, required=True, translate=True)
|
|
code = fields.Char('Code', size=None)
|
|
active = fields.Boolean('Active', select=True)
|
|
type = fields.Selection('get_types', 'Type', required=True)
|
|
view = fields.Many2One('account.journal.view', 'View')
|
|
update_posted = fields.Boolean('Allow updating posted moves')
|
|
sequence = fields.Property(fields.Many2One('ir.sequence', 'Sequence',
|
|
domain=[('code', '=', 'account.journal')],
|
|
context={'code': 'account.journal'},
|
|
states={
|
|
'required': Bool(Eval('context', {}).get('company', -1)),
|
|
}))
|
|
credit_account = fields.Property(fields.Many2One('account.account',
|
|
'Default Credit Account', domain=[
|
|
('kind', '!=', 'view'),
|
|
('company', '=', Eval('context', {}).get('company', -1)),
|
|
],
|
|
states={
|
|
'required': ((Eval('type').in_(['cash', 'write-off']))
|
|
& (Eval('context', {}).get('company', -1) != -1)),
|
|
'invisible': ~Eval('context', {}).get('company', -1),
|
|
}, depends=['type']))
|
|
debit_account = fields.Property(fields.Many2One('account.account',
|
|
'Default Debit Account', domain=[
|
|
('kind', '!=', 'view'),
|
|
('company', '=', Eval('context', {}).get('company', -1)),
|
|
],
|
|
states={
|
|
'required': ((Eval('type').in_(['cash', 'write-off']))
|
|
& (Eval('context', {}).get('company', -1) != -1)),
|
|
'invisible': ~Eval('context', {}).get('company', -1),
|
|
}, depends=['type']))
|
|
debit = fields.Function(fields.Numeric('Debit',
|
|
digits=(16, Eval('currency_digits', 2)),
|
|
depends=['currency_digits']), 'get_debit_credit_balance')
|
|
credit = fields.Function(fields.Numeric('Credit',
|
|
digits=(16, Eval('currency_digits', 2)),
|
|
depends=['currency_digits']), 'get_debit_credit_balance')
|
|
balance = fields.Function(fields.Numeric('Balance',
|
|
digits=(16, Eval('currency_digits', 2)),
|
|
depends=['currency_digits']), 'get_debit_credit_balance')
|
|
currency_digits = fields.Function(fields.Integer('Currency Digits'),
|
|
'get_currency_digits')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(Journal, cls).__setup__()
|
|
cls._order.insert(0, ('name', 'ASC'))
|
|
|
|
@classmethod
|
|
def __register__(cls, module_name):
|
|
TableHandler = backend.get('TableHandler')
|
|
super(Journal, cls).__register__(module_name)
|
|
cursor = Transaction().cursor
|
|
table = TableHandler(cursor, cls, module_name)
|
|
|
|
# Migration from 1.0 sequence Many2One change into Property
|
|
if table.column_exist('sequence'):
|
|
Property = Pool().get('ir.property')
|
|
sql_table = cls.__table__()
|
|
cursor.execute(*sql_table.select(sql_table.id, sql_table.sequence))
|
|
for journal_id, sequence_id in cursor.fetchall():
|
|
Property.set('sequence', cls._name,
|
|
journal_id, (sequence_id and
|
|
'ir.sequence,' + str(sequence_id) or False))
|
|
table.drop_column('sequence', exception=True)
|
|
|
|
@staticmethod
|
|
def default_active():
|
|
return True
|
|
|
|
@staticmethod
|
|
def default_update_posted():
|
|
return False
|
|
|
|
@staticmethod
|
|
def default_sequence():
|
|
return None
|
|
|
|
@staticmethod
|
|
def get_types():
|
|
Type = Pool().get('account.journal.type')
|
|
types = Type.search([])
|
|
return [(x.code, x.name) for x in types]
|
|
|
|
@classmethod
|
|
def search_rec_name(cls, name, clause):
|
|
if clause[1].startswith('!') or clause[1].startswith('not '):
|
|
bool_op = 'AND'
|
|
else:
|
|
bool_op = 'OR'
|
|
return [bool_op,
|
|
('code',) + tuple(clause[1:]),
|
|
(cls._rec_name,) + tuple(clause[1:]),
|
|
]
|
|
|
|
@classmethod
|
|
def get_currency_digits(cls, journals, name):
|
|
pool = Pool()
|
|
Company = pool.get('company.company')
|
|
company_id = Transaction().context.get('company')
|
|
if company_id:
|
|
company = Company(company_id)
|
|
digits = company.currency.digits
|
|
else:
|
|
digits = 2
|
|
return dict.fromkeys([j.id for j in journals], digits)
|
|
|
|
@classmethod
|
|
def get_debit_credit_balance(cls, journals, names):
|
|
pool = Pool()
|
|
MoveLine = pool.get('account.move.line')
|
|
Move = pool.get('account.move')
|
|
context = Transaction().context
|
|
cursor = Transaction().cursor
|
|
|
|
result = {}
|
|
ids = [j.id for j in journals]
|
|
for name in ['debit', 'credit', 'balance']:
|
|
result[name] = dict.fromkeys(ids, 0)
|
|
|
|
line = MoveLine.__table__()
|
|
move = Move.__table__()
|
|
where = ((move.date >= context['start_date'])
|
|
& (move.date <= context['end_date']))
|
|
for sub_journals in grouped_slice(journals):
|
|
sub_journals = list(sub_journals)
|
|
red_sql = reduce_ids(move.journal, [j.id for j in sub_journals])
|
|
accounts = None
|
|
for journal in sub_journals:
|
|
credit_account = (journal.credit_account.id
|
|
if journal.credit_account else None)
|
|
debit_account = (journal.debit_account.id
|
|
if journal.debit_account else None)
|
|
clause = ((move.journal == journal.id)
|
|
& (((line.credit != Null)
|
|
& (line.account == credit_account))
|
|
| ((line.debit != Null)
|
|
& (line.account == debit_account))))
|
|
if accounts is None:
|
|
accounts = clause
|
|
else:
|
|
accounts |= clause
|
|
|
|
query = line.join(move, 'LEFT', condition=line.move == move.id
|
|
).select(move.journal, Sum(line.debit), Sum(line.credit),
|
|
where=where & red_sql & accounts,
|
|
group_by=move.journal)
|
|
cursor.execute(*query)
|
|
for journal_id, debit, credit in cursor.fetchall():
|
|
# SQLite uses float for SUM
|
|
if not isinstance(debit, Decimal):
|
|
debit = Decimal(str(debit))
|
|
if not isinstance(credit, Decimal):
|
|
credit = Decimal(str(credit))
|
|
result['debit'][journal_id] = debit
|
|
result['credit'][journal_id] = credit
|
|
result['balance'][journal_id] = debit - credit
|
|
return result
|
|
|
|
|
|
class OpenJournalCash(Wizard):
|
|
'Open Journal Cash'
|
|
__name__ = 'account.journal.open_cash'
|
|
start = StateView('account.journal.open_cash.start',
|
|
'account.journal_open_cash_start_view_form', [
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Open', 'open_', 'tryton-ok', default=True),
|
|
])
|
|
open_ = StateAction('account.act_journal_open_cash')
|
|
|
|
def do_open_(self, action):
|
|
pool = Pool()
|
|
Lang = pool.get('ir.lang')
|
|
|
|
lang, = Lang.search([
|
|
('code', '=', Transaction().language),
|
|
])
|
|
|
|
action['pyson_context'] = PYSONEncoder().encode({
|
|
'start_date': self.start.start_date,
|
|
'end_date': self.start.end_date,
|
|
})
|
|
action['name'] += ' %s - %s' % (
|
|
Lang.strftime(self.start.start_date, lang.code, lang.date),
|
|
Lang.strftime(self.start.end_date, lang.code, lang.date))
|
|
return action, {}
|
|
|
|
|
|
class OpenJournalCashStart(ModelView):
|
|
'Open Journal Cash'
|
|
__name__ = 'account.journal.open_cash.start'
|
|
start_date = fields.Date('Start Date', required=True)
|
|
end_date = fields.Date('End Date', required=True)
|
|
|
|
@classmethod
|
|
def default_start_date(cls):
|
|
return Pool().get('ir.date').today()
|
|
default_end_date = default_start_date
|
|
|
|
|
|
class JournalPeriod(ModelSQL, ModelView):
|
|
'Journal - Period'
|
|
__name__ = 'account.journal.period'
|
|
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=True, states=STATES,
|
|
depends=DEPENDS)
|
|
state = fields.Selection([
|
|
('open', 'Open'),
|
|
('close', 'Close'),
|
|
], 'State', readonly=True, required=True)
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(JournalPeriod, cls).__setup__()
|
|
t = cls.__table__()
|
|
cls._sql_constraints += [
|
|
('journal_period_uniq', Unique(t, t.journal, t.period),
|
|
'You can only open one journal per period.'),
|
|
]
|
|
cls._order.insert(0, ('name', 'ASC'))
|
|
cls._error_messages.update({
|
|
'modify_del_journal_period': ('You can not modify/delete '
|
|
'journal - period "%s" because it has moves.'),
|
|
'create_journal_period': ('You can not create a '
|
|
'journal - period on closed period "%s".'),
|
|
'open_journal_period': ('You can not open '
|
|
'journal - period "%(journal_period)s" because period '
|
|
'"%(period)s" is closed.'),
|
|
})
|
|
|
|
@staticmethod
|
|
def default_active():
|
|
return True
|
|
|
|
@staticmethod
|
|
def default_state():
|
|
return 'open'
|
|
|
|
def get_icon(self, name):
|
|
return _ICONS.get(self.state, '')
|
|
|
|
@classmethod
|
|
def _check(cls, periods):
|
|
Move = Pool().get('account.move')
|
|
for period in periods:
|
|
moves = Move.search([
|
|
('journal', '=', period.journal.id),
|
|
('period', '=', period.period.id),
|
|
], limit=1)
|
|
if moves:
|
|
cls.raise_user_error('modify_del_journal_period', (
|
|
period.rec_name,))
|
|
|
|
@classmethod
|
|
def create(cls, vlist):
|
|
Period = Pool().get('account.period')
|
|
for vals in vlist:
|
|
if vals.get('period'):
|
|
period = Period(vals['period'])
|
|
if period.state == 'close':
|
|
cls.raise_user_error('create_journal_period', (
|
|
period.rec_name,))
|
|
return super(JournalPeriod, cls).create(vlist)
|
|
|
|
@classmethod
|
|
def write(cls, *args):
|
|
actions = iter(args)
|
|
for journal_periods, values in zip(actions, actions):
|
|
if (values != {'state': 'close'}
|
|
and values != {'state': 'open'}):
|
|
cls._check(journal_periods)
|
|
if values.get('state') == 'open':
|
|
for journal_period in journal_periods:
|
|
if journal_period.period.state == 'close':
|
|
cls.raise_user_error('open_journal_period', {
|
|
'journal_period': journal_period.rec_name,
|
|
'period': journal_period.period.rec_name,
|
|
})
|
|
super(JournalPeriod, cls).write(*args)
|
|
|
|
@classmethod
|
|
def delete(cls, periods):
|
|
cls._check(periods)
|
|
super(JournalPeriod, cls).delete(periods)
|
|
|
|
@classmethod
|
|
def close(cls, periods):
|
|
'''
|
|
Close journal - period
|
|
'''
|
|
cls.write(periods, {
|
|
'state': 'close',
|
|
})
|
|
|
|
@classmethod
|
|
def open_(cls, periods):
|
|
"Open journal - period"
|
|
cls.write(periods, {
|
|
'state': 'open',
|
|
})
|
|
|
|
|
|
class CloseJournalPeriod(Wizard):
|
|
'Close Journal - Period'
|
|
__name__ = 'account.journal.period.close'
|
|
start_state = 'close'
|
|
close = StateTransition()
|
|
|
|
def transition_close(self):
|
|
JournalPeriod = Pool().get('account.journal.period')
|
|
JournalPeriod.close(
|
|
JournalPeriod.browse(Transaction().context['active_ids']))
|
|
return 'end'
|
|
|
|
|
|
class ReOpenJournalPeriod(Wizard):
|
|
'Re-Open Journal - Period'
|
|
__name__ = 'account.journal.period.reopen'
|
|
start_state = 'reopen'
|
|
reopen = StateTransition()
|
|
|
|
def transition_reopen(self):
|
|
JournalPeriod = Pool().get('account.journal.period')
|
|
JournalPeriod.open_(
|
|
JournalPeriod.browse(Transaction().context['active_ids']))
|
|
return 'end'
|