Techsystech
/
account-financial-reporting
mirror of https://github.com/OCA/account-financial-reporting.git
3
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[pep8] - account_financial_report_webkit

pull/6/head
laetitia.gangloff@acsone.eu 2014-08-08 15:34:06 +02:00
parent 4c518c56fa
commit cc060dd31f
22 changed files with 1231 additions and 715 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
account_financial_report_webkit/__init__.py
View File

@ -17,7 +17,7 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
import account
from . import account
from . import wizard
from . import report
from . import account_move_line
from . import account_move_line

49
account_financial_report_webkit/__openerp__.py
View File

@ -35,7 +35,8 @@ This module adds or replaces the following standard OpenERP financial reports:
Main improvements per report:
-----------------------------
The General ledger: details of all entries posted in your books sorted by account.
The General ledger: details of all entries posted in your books sorted by
account.
* Filter by account is available in the wizard (no need to go to the
Chart of Accounts to do this anymore) or by View account (the report
@ -114,7 +115,8 @@ like the trial balance but add an extra information :
Overdue data are also split by period.
* For each partner following columns will be displayed:
* Total balance (all figures must match with same date partner balance report).
* Total balance (all figures must match with same date partner balance
report).
This column equals the sum of all following columns)
* Due
@ -126,11 +128,11 @@ like the trial balance but add an extra information :
Hypothesis / Contraints of aged partner balance
* Overdues columns will be by default be based on 30 days range fix number of days.
This can be changed by changes the RANGES constraint
* Overdues columns will be by default be based on 30 days range fix number of
days. This can be changed by changes the RANGES constraint
* All data will be displayed in company currency
* When partial payments, the payment must appear in the same colums than the invoice
(Except if multiple payment terms)
* When partial payments, the payment must appear in the same colums than the
invoice (Except if multiple payment terms)
* Data granularity: partner (will not display figures at invoices level)
* The report aggregate data per account with sub-totals
* Initial balance must be calculated the same way that
@ -173,25 +175,24 @@ wkhtmltopdf. The texts are defined inside the report classes.
'category': 'Finance',
'website': 'http://www.camptocamp.com',
'images': [
'images/ledger.png',],
'images/ledger.png', ],
'depends': ['account',
'report_webkit'],
'init_xml': [],
'demo_xml' : [],
'update_xml': ['account_view.xml',
'data/financial_webkit_header.xml',
'report/report.xml',
'wizard/wizard.xml',
'wizard/balance_common_view.xml',
'wizard/general_ledger_wizard_view.xml',
'wizard/partners_ledger_wizard_view.xml',
'wizard/trial_balance_wizard_view.xml',
'wizard/partner_balance_wizard_view.xml',
'wizard/open_invoices_wizard_view.xml',
'wizard/aged_partner_balance_wizard.xml',
'wizard/print_journal_view.xml',
'report_menus.xml',
],
'demo': [],
'data': ['account_view.xml',
'data/financial_webkit_header.xml',
'report/report.xml',
'wizard/wizard.xml',
'wizard/balance_common_view.xml',
'wizard/general_ledger_wizard_view.xml',
'wizard/partners_ledger_wizard_view.xml',
'wizard/trial_balance_wizard_view.xml',
'wizard/partner_balance_wizard_view.xml',
'wizard/open_invoices_wizard_view.xml',
'wizard/aged_partner_balance_wizard.xml',
'wizard/print_journal_view.xml',
'report_menus.xml',
],
# tests order matter
'test': ['tests/general_ledger.yml',
'tests/partner_ledger.yml',
@ -199,7 +200,7 @@ wkhtmltopdf. The texts are defined inside the report classes.
'tests/partner_balance.yml',
'tests/open_invoices.yml',
'tests/aged_trial_balance.yml'],
#'tests/account_move_line.yml'
# 'tests/account_move_line.yml'
'active': False,
'installable': True,
'application': True,

45
account_financial_report_webkit/account_move_line.py
View File

@ -20,16 +20,18 @@
##############################################################################
from openerp.osv import fields, orm
from openerp.tools.translate import _
class AccountMoveLine(orm.Model):
"""Overriding Account move line in order to add last_rec_date.
Last rec date is the date of the last reconciliation (full or partial) account move line"""
Last rec date is the date of the last reconciliation (full or partial)
account move line"""
_inherit = 'account.move.line'
def init(self, cr):
##We do not want to catch error as if sql is not run it will give invalid data
# We do not want to catch error as if sql is not run it will give
# invalid data
cr.execute("UPDATE account_move_line as acm "
" SET last_rec_date ="
" (SELECT date from account_move_line"
@ -41,14 +43,16 @@ class AccountMoveLine(orm.Model):
cr.execute("UPDATE account_move_line as acm "
" SET last_rec_date ="
" (SELECT date from account_move_line"
" WHERE reconcile_partial_id = acm.reconcile_partial_id"
" WHERE reconcile_partial_id"
" = acm.reconcile_partial_id"
" AND reconcile_partial_id IS NOT NULL"
" ORDER BY date DESC LIMIT 1)"
" WHERE last_rec_date is null;")
def _get_move_line_from_line_rec(self, cr, uid, ids, context=None):
moves = []
for reconcile in self.pool.get('account.move.reconcile').browse(cr, uid, ids, context=context):
for reconcile in self.pool['account.move.reconcile'].browse(
cr, uid, ids, context=context):
for move_line in reconcile.line_partial_ids:
moves.append(move_line.id)
for move_line in reconcile.line_id:
@ -64,22 +68,27 @@ class AccountMoveLine(orm.Model):
rec = line.reconcile_id or line.reconcile_partial_id or False
if rec:
# we use cursor in order to gain some perfs
cursor.execute('SELECT date from account_move_line where'
' reconcile_id = %s OR reconcile_partial_id = %s'
' ORDER BY date DESC LIMIT 1 ',
(rec.id, rec.id))
cursor.execute('SELECT date from account_move_line'
' WHERE reconcile_id = %s'
' OR reconcile_partial_id = %s'
' ORDER BY date DESC LIMIT 1 ',
(rec.id, rec.id))
res_set = cursor.fetchone()
if res_set:
res[line.id] = {'last_rec_date': res_set[0]}
return res
_columns = {
'last_rec_date': fields.function(_get_last_rec_date,
method=True,
string='Last reconciliation date',
store={'account.move.line': (lambda self, cr, uid, ids, c={}: ids, ['date'], 20),
'account.move.reconcile': (_get_move_line_from_line_rec, None, 20)},
type='date',
multi='all',
help="the date of the last reconciliation (full or partial) account move line"),
}
'last_rec_date': fields.function(
_get_last_rec_date,
method=True,
string='Last reconciliation date',
store={'account.move.line': (lambda self, cr, uid, ids, c={}: ids,
['date'], 20),
'account.move.reconcile': (_get_move_line_from_line_rec,
None, 20)},
type='date',
multi='all',
help="the date of the last reconciliation (full or partial) \
account move line"),
}

37
account_financial_report_webkit/report/aged_partner_balance.py
View File

@ -35,14 +35,15 @@ def make_ranges(top, offset):
:param offset: offset for ranges
:returns: list of sorted ranges tuples in days
eg. [(-100000, 0), (0, offset), (offset, n*offset), ... (top, 100000)]
eg. [(-100000, 0), (0, offset),
(offset, n*offset), ... (top, 100000)]
"""
ranges = [(n, min(n + offset, top)) for n in xrange(0, top, offset)]
ranges.insert(0, (-100000000000, 0))
ranges.append((top, 100000000000))
return ranges
#list of overdue ranges
# list of overdue ranges
RANGES = make_ranges(120, 30)
@ -53,20 +54,22 @@ def make_ranges_titles():
titles.append(_('Older'))
return titles
#list of overdue ranges title
# list of overdue ranges title
RANGES_TITLES = make_ranges_titles()
#list of payable journal types
# list of payable journal types
REC_PAY_TYPE = ('purchase', 'sale')
#list of refund payable type
# list of refund payable type
REFUND_TYPE = ('purchase_refund', 'sale_refund')
INV_TYPE = REC_PAY_TYPE + REFUND_TYPE
class AccountAgedTrialBalanceWebkit(PartnersOpenInvoicesWebkit):
"""Compute Aged Partner Balance based on result of Open Invoices"""
def __init__(self, cursor, uid, name, context=None):
"""Constructor, refer to :class:`openerp.report.report_sxw.rml_parse`"""
"""Constructor,
refer to :class:`openerp.report.report_sxw.rml_parse`"""
super(AccountAgedTrialBalanceWebkit, self).__init__(cursor, uid, name,
context=context)
self.pool = pooler.get_pool(self.cr.dbname)
@ -95,7 +98,8 @@ class AccountAgedTrialBalanceWebkit(PartnersOpenInvoicesWebkit):
('--header-left', header_report_name),
('--header-spacing', '2'),
('--footer-left', footer_date_time),
('--footer-right', ' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-right',
' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-line',),
],
})
@ -141,9 +145,10 @@ class AccountAgedTrialBalanceWebkit(PartnersOpenInvoicesWebkit):
data)
if aged_lines:
acc.aged_lines[part_id] = aged_lines
acc.aged_totals = totals = self.compute_totals(acc.aged_lines.values())
acc.aged_totals = totals = self.compute_totals(
acc.aged_lines.values())
acc.aged_percents = self.compute_percents(totals)
#Free some memory
# Free some memory
del(acc.ledger_lines)
return res
@ -265,17 +270,18 @@ class AccountAgedTrialBalanceWebkit(PartnersOpenInvoicesWebkit):
:returns: delta in days
"""
sale_lines = [x for x in ledger_lines if x['jtype'] in REC_PAY_TYPE and
line['rec_id'] == x['rec_id']]
refund_lines = [x for x in ledger_lines if x['jtype'] in REFUND_TYPE and
line['rec_id'] == x['rec_id']]
sale_lines = [x for x in ledger_lines if x['jtype'] in REC_PAY_TYPE
and line['rec_id'] == x['rec_id']]
refund_lines = [x for x in ledger_lines if x['jtype'] in REFUND_TYPE
and line['rec_id'] == x['rec_id']]
if len(sale_lines) == 1:
reference_line = sale_lines[0]
elif len(refund_lines) == 1:
reference_line = refund_lines[0]
else:
reference_line = line
key = 'date_maturity' if reference_line.get('date_maturity') else 'ldate'
key = 'date_maturity' if reference_line.get(
'date_maturity') else 'ldate'
return self._compute_delay_from_key(key,
reference_line,
end_date)
@ -398,6 +404,7 @@ class AccountAgedTrialBalanceWebkit(PartnersOpenInvoicesWebkit):
HeaderFooterTextWebKitParser(
'report.account.account_aged_trial_balance_webkit',
'account.account',
'addons/account_financial_report_webkit/report/templates/aged_trial_webkit.mako',
'addons/account_financial_report_webkit/report/templates/\
aged_trial_webkit.mako',
parser=AccountAgedTrialBalanceWebkit,
)

170
account_financial_report_webkit/report/common_balance_reports.py
View File

@ -26,7 +26,9 @@ from .common_reports import CommonReportHeaderWebkit
class CommonBalanceReportHeaderWebkit(CommonReportHeaderWebkit):
"""Define common helper for balance (trial balance, P&L, BS oriented financial report"""
"""Define common helper for balance (trial balance, P&L, BS oriented
financial report"""
def _get_numbers_display(self, data):
return self._get_form_param('numbers_display', data)
@ -35,7 +37,9 @@ class CommonBalanceReportHeaderWebkit(CommonReportHeaderWebkit):
def find_key_by_value_in_list(dic, value):
return [key for key, val in dic.iteritems() if value in val][0]
def _get_account_details(self, account_ids, target_move, fiscalyear, main_filter, start, stop, initial_balance_mode, context=None):
def _get_account_details(self, account_ids, target_move, fiscalyear,
main_filter, start, stop, initial_balance_mode,
context=None):
"""
Get details of accounts to display on the report
@param account_ids: ids of accounts to get details
@ -44,21 +48,26 @@ class CommonBalanceReportHeaderWebkit(CommonReportHeaderWebkit):
@param main_filter: selection filter period / date or none
@param start: start date or start period browse instance
@param stop: stop date or stop period browse instance
@param initial_balance_mode: False: no calculation, 'opening_balance': from the opening period, 'initial_balance': computed from previous year / periods
@return: dict of list containing accounts details, keys are the account ids
@param initial_balance_mode: False: no calculation,
'opening_balance': from the opening period,
'initial_balance': computed from previous year / periods
@return: dict of list containing accounts details, keys are
the account ids
"""
if context is None:
context = {}
account_obj = self.pool.get('account.account')
period_obj = self.pool.get('account.period')
use_period_ids = main_filter in ('filter_no', 'filter_period', 'filter_opening')
use_period_ids = main_filter in (
'filter_no', 'filter_period', 'filter_opening')
if use_period_ids:
if main_filter == 'filter_opening':
period_ids = [start.id]
else:
period_ids = period_obj.build_ctx_periods(self.cursor, self.uid, start.id, stop.id)
period_ids = period_obj.build_ctx_periods(
self.cursor, self.uid, start.id, stop.id)
# never include the opening in the debit / credit amounts
period_ids = self.exclude_opening_periods(period_ids)
@ -66,7 +75,8 @@ class CommonBalanceReportHeaderWebkit(CommonReportHeaderWebkit):
if initial_balance_mode == 'opening_balance':
init_balance = self._read_opening_balance(account_ids, start)
elif initial_balance_mode:
init_balance = self._compute_initial_balances(account_ids, start, fiscalyear)
init_balance = self._compute_initial_balances(
account_ids, start, fiscalyear)
ctx = context.copy()
ctx.update({'state': target_move,
@ -79,42 +89,52 @@ class CommonBalanceReportHeaderWebkit(CommonReportHeaderWebkit):
'date_to': stop})
accounts = account_obj.read(
self.cursor,
self.uid,
account_ids,
['type', 'code', 'name', 'debit', 'credit', 'balance', 'parent_id', 'level', 'child_id'],
ctx)
self.cursor,
self.uid,
account_ids,
['type', 'code', 'name', 'debit', 'credit',
'balance', 'parent_id', 'level', 'child_id'],
ctx)
accounts_by_id = {}
for account in accounts:
if init_balance:
# sum for top level views accounts
child_ids = account_obj._get_children_and_consol(self.cursor, self.uid, account['id'], ctx)
child_ids = account_obj._get_children_and_consol(
self.cursor, self.uid, account['id'], ctx)
if child_ids:
child_init_balances = [
init_bal['init_balance']
for acnt_id, init_bal in init_balance.iteritems()
if acnt_id in child_ids]
init_bal['init_balance']
for acnt_id, init_bal in init_balance.iteritems()
if acnt_id in child_ids]
top_init_balance = reduce(add, child_init_balances)
account['init_balance'] = top_init_balance
else:
account.update(init_balance[account['id']])
account['balance'] = account['init_balance'] + account['debit'] - account['credit']
account['balance'] = account['init_balance'] + \
account['debit'] - account['credit']
accounts_by_id[account['id']] = account
return accounts_by_id
def _get_comparison_details(self, data, account_ids, target_move, comparison_filter, index):
def _get_comparison_details(self, data, account_ids, target_move,
comparison_filter, index):
"""
@param data: data of the wizard form
@param account_ids: ids of the accounts to get details
@param comparison_filter: selected filter on the form for the comparison (filter_no, filter_year, filter_period, filter_date)
@param index: index of the fields to get (ie. comp1_fiscalyear_id where 1 is the index)
@param comparison_filter: selected filter on the form for
the comparison (filter_no, filter_year, filter_period,
filter_date)
@param index: index of the fields to get
(ie. comp1_fiscalyear_id where 1 is the index)
@return: dict of account details (key = account id)
"""
fiscalyear = self._get_info(data, "comp%s_fiscalyear_id" % (index,), 'account.fiscalyear')
start_period = self._get_info(data, "comp%s_period_from" % (index,), 'account.period')
stop_period = self._get_info(data, "comp%s_period_to" % (index,), 'account.period')
fiscalyear = self._get_info(
data, "comp%s_fiscalyear_id" % (index,), 'account.fiscalyear')
start_period = self._get_info(
data, "comp%s_period_from" % (index,), 'account.period')
stop_period = self._get_info(
data, "comp%s_period_to" % (index,), 'account.period')
start_date = self._get_form_param("comp%s_date_from" % (index,), data)
stop_date = self._get_form_param("comp%s_date_to" % (index,), data)
init_balance = self.is_initial_balance_enabled(comparison_filter)
@ -124,13 +144,17 @@ class CommonBalanceReportHeaderWebkit(CommonReportHeaderWebkit):
details_filter = comparison_filter
if comparison_filter != 'filter_no':
start_period, stop_period, start, stop = \
self._get_start_stop_for_filter(comparison_filter, fiscalyear, start_date, stop_date, start_period, stop_period)
self._get_start_stop_for_filter(
comparison_filter, fiscalyear, start_date, stop_date,
start_period, stop_period)
if comparison_filter == 'filter_year':
details_filter = 'filter_no'
initial_balance_mode = init_balance and self._get_initial_balance_mode(start) or False
accounts_by_ids = self._get_account_details(account_ids, target_move, fiscalyear, details_filter,
start, stop, initial_balance_mode)
initial_balance_mode = init_balance \
and self._get_initial_balance_mode(start) or False
accounts_by_ids = self._get_account_details(
account_ids, target_move, fiscalyear, details_filter,
start, stop, initial_balance_mode)
comp_params = {
'comparison_filter': comparison_filter,
'fiscalyear': fiscalyear,
@ -146,14 +170,16 @@ class CommonBalanceReportHeaderWebkit(CommonReportHeaderWebkit):
"""
@param balance: current balance
@param previous_balance: last balance
@return: dict of form {'diff': difference, 'percent_diff': diff in percentage}
@return: dict of form {'diff': difference,
'percent_diff': diff in percentage}
"""
diff = balance - previous_balance
obj_precision = self.pool.get('decimal.precision')
precision = obj_precision.precision_get(self.cursor, self.uid, 'Account')
# round previous balance with account precision to avoid big numbers if previous
# balance is 0.0000001 or a any very small number
precision = obj_precision.precision_get(
self.cursor, self.uid, 'Account')
# round previous balance with account precision to avoid big numbers
# if previous balance is 0.0000001 or a any very small number
if round(previous_balance, precision) == 0:
percent_diff = False
else:
@ -165,13 +191,18 @@ class CommonBalanceReportHeaderWebkit(CommonReportHeaderWebkit):
"""
@param data: data of the report
@param comparison_number: number of comparisons
@return: list of comparison filters, nb of comparisons used and comparison mode (no_comparison, single, multiple)
@return: list of comparison filters, nb of comparisons used and
comparison mode (no_comparison, single, multiple)
"""
comp_filters = []
for index in range(comparison_number):
comp_filters.append(self._get_form_param("comp%s_filter" % (index,), data, default='filter_no'))
comp_filters.append(
self._get_form_param("comp%s_filter" % (index,), data,
default='filter_no'))
nb_comparisons = len([comp_filter for comp_filter in comp_filters if comp_filter != 'filter_no'])
nb_comparisons = len(
[comp_filter for comp_filter in comp_filters
if comp_filter != 'filter_no'])
if not nb_comparisons:
comparison_mode = 'no_comparison'
elif nb_comparisons > 1:
@ -180,12 +211,14 @@ class CommonBalanceReportHeaderWebkit(CommonReportHeaderWebkit):
comparison_mode = 'single'
return comp_filters, nb_comparisons, comparison_mode
def _get_start_stop_for_filter(self, main_filter, fiscalyear, start_date, stop_date, start_period, stop_period):
def _get_start_stop_for_filter(self, main_filter, fiscalyear, start_date,
stop_date, start_period, stop_period):
if main_filter in ('filter_no', 'filter_year'):
start_period = self.get_first_fiscalyear_period(fiscalyear)
stop_period = self.get_last_fiscalyear_period(fiscalyear)
elif main_filter == 'filter_opening':
opening_period = self._get_st_fiscalyear_period(fiscalyear, special=True)
opening_period = self._get_st_fiscalyear_period(
fiscalyear, special=True)
start_period = stop_period = opening_period
if main_filter == 'filter_date':
start = start_date
@ -197,11 +230,14 @@ class CommonBalanceReportHeaderWebkit(CommonReportHeaderWebkit):
return start_period, stop_period, start, stop
def compute_balance_data(self, data, filter_report_type=None):
new_ids = data['form']['account_ids'] or data['form']['chart_account_id']
max_comparison = self._get_form_param('max_comparison', data, default=0)
new_ids = data['form']['account_ids'] or data[
'form']['chart_account_id']
max_comparison = self._get_form_param(
'max_comparison', data, default=0)
main_filter = self._get_form_param('filter', data, default='filter_no')
comp_filters, nb_comparisons, comparison_mode = self._comp_filters(data, max_comparison)
comp_filters, nb_comparisons, comparison_mode = self._comp_filters(
data, max_comparison)
fiscalyear = self.get_fiscalyear_br(data)
@ -214,51 +250,75 @@ class CommonBalanceReportHeaderWebkit(CommonReportHeaderWebkit):
chart_account = self._get_chart_account_id_br(data)
start_period, stop_period, start, stop = \
self._get_start_stop_for_filter(main_filter, fiscalyear, start_date, stop_date, start_period, stop_period)
self._get_start_stop_for_filter(main_filter, fiscalyear,
start_date, stop_date,
start_period, stop_period)
init_balance = self.is_initial_balance_enabled(main_filter)
initial_balance_mode = init_balance and self._get_initial_balance_mode(start) or False
initial_balance_mode = init_balance and self._get_initial_balance_mode(
start) or False
# Retrieving accounts
account_ids = self.get_all_accounts(new_ids, only_type=filter_report_type)
account_ids = self.get_all_accounts(
new_ids, only_type=filter_report_type)
# get details for each accounts, total of debit / credit / balance
accounts_by_ids = self._get_account_details(account_ids, target_move, fiscalyear, main_filter, start, stop, initial_balance_mode)
accounts_by_ids = self._get_account_details(
account_ids, target_move, fiscalyear, main_filter, start, stop,
initial_balance_mode)
comparison_params = []
comp_accounts_by_ids = []
for index in range(max_comparison):
if comp_filters[index] != 'filter_no':
comparison_result, comp_params = self._get_comparison_details(data, account_ids, target_move, comp_filters[index], index)
comparison_result, comp_params = self._get_comparison_details(
data, account_ids, target_move, comp_filters[index], index)
comparison_params.append(comp_params)
comp_accounts_by_ids.append(comparison_result)
to_display = dict.fromkeys(account_ids, True)
objects = []
for account in self.pool.get('account.account').browse(self.cursor, self.uid, account_ids):
for account in self.pool.get('account.account').browse(self.cursor,
self.uid,
account_ids):
if not account.parent_id: # hide top level account
continue
if account.type == 'consolidation':
to_display.update(dict([(a.id, False) for a in account.child_consol_ids]))
to_display.update(
dict([(a.id, False) for a in account.child_consol_ids]))
elif account.type == 'view':
to_display.update(dict([(a.id, True) for a in account.child_id]))
to_display.update(
dict([(a.id, True) for a in account.child_id]))
account.debit = accounts_by_ids[account.id]['debit']
account.credit = accounts_by_ids[account.id]['credit']
account.balance = accounts_by_ids[account.id]['balance']
account.init_balance = accounts_by_ids[account.id].get('init_balance', 0.0)
account.init_balance = accounts_by_ids[
account.id].get('init_balance', 0.0)
display_account = False # if any amount is != 0 in comparisons, we have to display the whole account
# if any amount is != 0 in comparisons, we have to display the
# whole account
display_account = False
comp_accounts = []
for comp_account_by_id in comp_accounts_by_ids:
values = comp_account_by_id.get(account.id)
values.update(self._get_diff(account.balance, values['balance']))
display_account = any((values.get('credit', 0.0), values.get('debit', 0.0), values.get('balance', 0.0), values.get('init_balance', 0.0)))
values.update(
self._get_diff(account.balance, values['balance']))
display_account = any((values.get('credit', 0.0),
values.get('debit', 0.0),
values.get('balance', 0.0),
values.get('init_balance', 0.0)))
comp_accounts.append(values)
account.comparisons = comp_accounts
# we have to display the account if a comparison as an amount or if we have an amount in the main column
# we set it as a property to let the data in the report if someone want to use it in a custom report
display_account = display_account or any((account.debit, account.credit, account.balance, account.init_balance))
to_display.update({account.id: display_account and to_display[account.id]})
# we have to display the account if a comparison as an amount or
# if we have an amount in the main column
# we set it as a property to let the data in the report if someone
# want to use it in a custom report
display_account = display_account or any((account.debit,
account.credit,
account.balance,
account.init_balance))
to_display.update(
{account.id: display_account and to_display[account.id]})
objects.append(account)
for account in objects:

208
account_financial_report_webkit/report/common_partner_balance_reports.py
View File

@ -27,11 +27,16 @@ from .common_balance_reports import CommonBalanceReportHeaderWebkit
from .common_partner_reports import CommonPartnersReportHeaderWebkit
class CommonPartnerBalanceReportHeaderWebkit(CommonBalanceReportHeaderWebkit, CommonPartnersReportHeaderWebkit):
"""Define common helper for balance (trial balance, P&L, BS oriented financial report"""
class CommonPartnerBalanceReportHeaderWebkit(CommonBalanceReportHeaderWebkit,
CommonPartnersReportHeaderWebkit):
def _get_account_partners_details(self, account_by_ids, main_filter, target_move, start,
stop, initial_balance_mode, partner_filter_ids=False):
"""Define common helper for balance (trial balance, P&L,
BS oriented financial report"""
def _get_account_partners_details(self, account_by_ids, main_filter,
target_move, start, stop,
initial_balance_mode,
partner_filter_ids=False):
res = {}
filter_from = False
if main_filter in ('filter_period', 'filter_no', 'filter_opening'):
@ -41,51 +46,71 @@ class CommonPartnerBalanceReportHeaderWebkit(CommonBalanceReportHeaderWebkit, Co
partners_init_balances_by_ids = {}
for account_id, account_details in account_by_ids.iteritems():
partners_init_balances_by_ids.update(self._get_partners_initial_balances(account_id,
start,
initial_balance_mode,
partner_filter_ids=partner_filter_ids,
exclude_reconcile=False)) # we'll never exclude reconciled entries in the legal reports
partners_init_balances_by_ids.update(
self._get_partners_initial_balances(
account_id, start, initial_balance_mode,
partner_filter_ids=partner_filter_ids,
# we'll never exclude reconciled entries in the legal
# reports
exclude_reconcile=False))
opening_mode = 'exclude_opening'
if main_filter == 'filter_opening':
opening_mode = 'include_opening'
# get credit and debit for partner
details = self._get_partners_totals_account(filter_from,
account_id,
start,
stop,
target_move,
partner_filter_ids=partner_filter_ids,
mode=opening_mode)
details = self._get_partners_totals_account(
filter_from,
account_id,
start,
stop,
target_move,
partner_filter_ids=partner_filter_ids,
mode=opening_mode)
# merge initial balances in partner details
if partners_init_balances_by_ids.get(account_id):
for partner_id, initial_balances in partners_init_balances_by_ids[account_id].iteritems():
for partner_id, initial_balances in \
partners_init_balances_by_ids[account_id].iteritems():
if initial_balances.get('init_balance'):
details[partner_id].update({'init_balance': initial_balances['init_balance']})
details[partner_id].update(
{'init_balance': initial_balances['init_balance']})
# compute balance for the partner
for partner_id, partner_details in details.iteritems():
details[partner_id]['balance'] = details[partner_id].get('init_balance', 0.0) +\
details[partner_id].get('debit', 0.0) -\
details[partner_id].get('credit', 0.0)
details[partner_id]['balance'] = details[partner_id].\
get('init_balance', 0.0) + \
details[partner_id].get('debit', 0.0) - \
details[partner_id].get('credit', 0.0)
res[account_id] = details
return res
def _get_partners_initial_balances(self, account_ids, start_period, initial_balance_mode, partner_filter_ids=None, exclude_reconcile=False):
# we get the initial balance from the opening period (opening_balance) when the opening period is included in the start period and
# when there is at least one entry in the opening period. Otherwise we compute it from previous periods
def _get_partners_initial_balances(self, account_ids, start_period,
initial_balance_mode,
partner_filter_ids=None,
exclude_reconcile=False):
# we get the initial balance from the opening period (opening_balance)
# when the opening period is included in the start period and
# when there is at least one entry in the opening period. Otherwise we
# compute it from previous periods
if initial_balance_mode == 'opening_balance':
opening_period_selected = self.get_included_opening_period(start_period)
res = self._compute_partners_initial_balances(account_ids, start_period, partner_filter_ids, force_period_ids=opening_period_selected, exclude_reconcile=exclude_reconcile)
opening_period_selected = self.get_included_opening_period(
start_period)
res = self._compute_partners_initial_balances(
account_ids, start_period, partner_filter_ids,
force_period_ids=opening_period_selected,
exclude_reconcile=exclude_reconcile)
elif initial_balance_mode == 'initial_balance':
res = self._compute_partners_initial_balances(account_ids, start_period, partner_filter_ids, exclude_reconcile=exclude_reconcile)
res = self._compute_partners_initial_balances(
account_ids, start_period, partner_filter_ids,
exclude_reconcile=exclude_reconcile)
else:
res = {}
return res
def _get_partners_totals_account(self, filter_from, account_id, start, stop, target_move, partner_filter_ids=None, mode='exclude_opening'):
def _get_partners_totals_account(self, filter_from, account_id, start,
stop, target_move,
partner_filter_ids=None,
mode='exclude_opening'):
final_res = defaultdict(dict)
sql_select = """
@ -94,17 +119,20 @@ class CommonPartnerBalanceReportHeaderWebkit(CommonBalanceReportHeaderWebkit, Co
sum(account_move_line.credit) AS credit
FROM account_move_line"""
sql_joins = ''
sql_where = "WHERE account_move_line.account_id = %(account_id)s AND account_move_line.state = 'valid' "
sql_where = "WHERE account_move_line.account_id = %(account_id)s \
AND account_move_line.state = 'valid' "
method = getattr(self, '_get_query_params_from_' + filter_from + 's')
sql_conditions, search_params = method(start, stop, mode=mode)
sql_where += sql_conditions
if partner_filter_ids:
sql_where += " AND account_move_line.partner_id in %(partner_ids)s"
sql_where += " AND account_move_line.partner_id \
in %(partner_ids)s"
search_params.update({'partner_ids': tuple(partner_filter_ids)})
if target_move == 'posted':
sql_joins += "INNER JOIN account_move ON account_move_line.move_id = account_move.id"
sql_joins += "INNER JOIN account_move \
ON account_move_line.move_id = account_move.id"
sql_where += " AND account_move.state = %(target_move)s"
search_params.update({'target_move': target_move})
@ -128,19 +156,26 @@ class CommonPartnerBalanceReportHeaderWebkit(CommonBalanceReportHeaderWebkit, Co
filter_type = ('payable',)
return filter_type
def _get_partners_comparison_details(self, data, account_ids, target_move, comparison_filter, index, partner_filter_ids=False):
def _get_partners_comparison_details(self, data, account_ids, target_move,
comparison_filter, index,
partner_filter_ids=False):
"""
@param data: data of the wizard form
@param account_ids: ids of the accounts to get details
@param comparison_filter: selected filter on the form for the comparison (filter_no, filter_year, filter_period, filter_date)
@param index: index of the fields to get (ie. comp1_fiscalyear_id where 1 is the index)
@param comparison_filter: selected filter on the form for
the comparison (filter_no, filter_year, filter_period, filter_date)
@param index: index of the fields to get (ie. comp1_fiscalyear_id
where 1 is the index)
@param partner_filter_ids: list of ids of partners to select
@return: dict of account details (key = account id)
"""
fiscalyear = self._get_info(data, "comp%s_fiscalyear_id" % (index,), 'account.fiscalyear')
start_period = self._get_info(data, "comp%s_period_from" % (index,), 'account.period')
stop_period = self._get_info(data, "comp%s_period_to" % (index,), 'account.period')
fiscalyear = self._get_info(
data, "comp%s_fiscalyear_id" % (index,), 'account.fiscalyear')
start_period = self._get_info(
data, "comp%s_period_from" % (index,), 'account.period')
stop_period = self._get_info(
data, "comp%s_period_to" % (index,), 'account.period')
start_date = self._get_form_param("comp%s_date_from" % (index,), data)
stop_date = self._get_form_param("comp%s_date_to" % (index,), data)
init_balance = self.is_initial_balance_enabled(comparison_filter)
@ -149,22 +184,30 @@ class CommonPartnerBalanceReportHeaderWebkit(CommonBalanceReportHeaderWebkit, Co
accounts_details_by_ids = defaultdict(dict)
if comparison_filter != 'filter_no':
start_period, stop_period, start, stop = \
self._get_start_stop_for_filter(comparison_filter, fiscalyear, start_date, stop_date, start_period, stop_period)
self._get_start_stop_for_filter(
comparison_filter, fiscalyear, start_date, stop_date,
start_period, stop_period)
details_filter = comparison_filter
if comparison_filter == 'filter_year':
details_filter = 'filter_no'
initial_balance_mode = init_balance and self._get_initial_balance_mode(start) or False
initial_balance_mode = init_balance \
and self._get_initial_balance_mode(start) or False
accounts_by_ids = self._get_account_details(account_ids, target_move, fiscalyear, details_filter, start, stop, initial_balance_mode)
accounts_by_ids = self._get_account_details(
account_ids, target_move, fiscalyear, details_filter, start,
stop, initial_balance_mode)
partner_details_by_ids = self._get_account_partners_details(accounts_by_ids, details_filter,
target_move, start, stop, initial_balance_mode,
partner_filter_ids=partner_filter_ids)
partner_details_by_ids = self._get_account_partners_details(
accounts_by_ids, details_filter,
target_move, start, stop, initial_balance_mode,
partner_filter_ids=partner_filter_ids)
for account_id in account_ids:
accounts_details_by_ids[account_id]['account'] = accounts_by_ids[account_id]
accounts_details_by_ids[account_id]['partners_amounts'] = partner_details_by_ids[account_id]
accounts_details_by_ids[account_id][
'account'] = accounts_by_ids[account_id]
accounts_details_by_ids[account_id][
'partners_amounts'] = partner_details_by_ids[account_id]
comp_params = {
'comparison_filter': comparison_filter,
@ -177,11 +220,14 @@ class CommonPartnerBalanceReportHeaderWebkit(CommonBalanceReportHeaderWebkit, Co
return accounts_details_by_ids, comp_params
def compute_partner_balance_data(self, data, filter_report_type=None):
new_ids = data['form']['account_ids'] or data['form']['chart_account_id']
max_comparison = self._get_form_param('max_comparison', data, default=0)
new_ids = data['form']['account_ids'] or data[
'form']['chart_account_id']
max_comparison = self._get_form_param(
'max_comparison', data, default=0)
main_filter = self._get_form_param('filter', data, default='filter_no')
comp_filters, nb_comparisons, comparison_mode = self._comp_filters(data, max_comparison)
comp_filters, nb_comparisons, comparison_mode = self._comp_filters(
data, max_comparison)
fiscalyear = self.get_fiscalyear_br(data)
@ -197,62 +243,78 @@ class CommonPartnerBalanceReportHeaderWebkit(CommonBalanceReportHeaderWebkit, Co
filter_type = self._get_filter_type(result_selection)
start_period, stop_period, start, stop = \
self._get_start_stop_for_filter(main_filter, fiscalyear, start_date, stop_date, start_period, stop_period)
self._get_start_stop_for_filter(
main_filter, fiscalyear, start_date, stop_date, start_period,
stop_period)
initial_balance = self.is_initial_balance_enabled(main_filter)
initial_balance_mode = initial_balance and self._get_initial_balance_mode(start) or False
initial_balance_mode = initial_balance \
and self._get_initial_balance_mode(start) or False
# Retrieving accounts
account_ids = self.get_all_accounts(new_ids, only_type=filter_type,
filter_report_type=filter_report_type)
account_ids = self.get_all_accounts(
new_ids, only_type=filter_type,
filter_report_type=filter_report_type)
# get details for each accounts, total of debit / credit / balance
accounts_by_ids = self._get_account_details(account_ids, target_move, fiscalyear, main_filter, start, stop, initial_balance_mode)
accounts_by_ids = self._get_account_details(
account_ids, target_move, fiscalyear, main_filter, start, stop,
initial_balance_mode)
partner_details_by_ids = self._get_account_partners_details(accounts_by_ids,
main_filter,
target_move,
start,
stop,
initial_balance_mode,
partner_filter_ids=partner_ids)
partner_details_by_ids = self._get_account_partners_details(
accounts_by_ids, main_filter, target_move, start, stop,
initial_balance_mode, partner_filter_ids=partner_ids)
comparison_params = []
comp_accounts_by_ids = []
for index in range(max_comparison):
if comp_filters[index] != 'filter_no':
comparison_result, comp_params = self._get_partners_comparison_details(data, account_ids,
target_move, comp_filters[index],
index, partner_filter_ids=partner_ids)
comparison_result, comp_params = self.\
_get_partners_comparison_details(
data, account_ids,
target_move,
comp_filters[index],
index,
partner_filter_ids=partner_ids)
comparison_params.append(comp_params)
comp_accounts_by_ids.append(comparison_result)
objects = []
for account in self.pool.get('account.account').browse(self.cursor, self.uid, account_ids):
for account in self.pool.get('account.account').browse(self.cursor,
self.uid,
account_ids):
if not account.parent_id: # hide top level account
continue
account.debit = accounts_by_ids[account.id]['debit']
account.credit = accounts_by_ids[account.id]['credit']
account.balance = accounts_by_ids[account.id]['balance']
account.init_balance = accounts_by_ids[account.id].get('init_balance', 0.0)
account.init_balance = accounts_by_ids[
account.id].get('init_balance', 0.0)
account.partners_amounts = partner_details_by_ids[account.id]
comp_accounts = []
for comp_account_by_id in comp_accounts_by_ids:
values = comp_account_by_id.get(account.id)
values['account'].update(self._get_diff(account.balance, values['account'].get('balance', 0.0)))
values['account'].update(
self._get_diff(account.balance,
values['account'].get('balance', 0.0)))
comp_accounts.append(values)
for partner_id, partner_values in values['partners_amounts'].copy().iteritems():
base_partner_balance = account.partners_amounts[partner_id]['balance'] if \
account.partners_amounts.get(partner_id) else 0.0
partner_values.update(self._get_diff(base_partner_balance,
partner_values.get('balance', 0.0)))
values['partners_amounts'][partner_id].update(partner_values)
for partner_id, partner_values in \
values['partners_amounts'].copy().iteritems():
base_partner_balance = account.partners_amounts[
partner_id]['balance'] if \
account.partners_amounts.get(partner_id) else 0.0
partner_values.update(self._get_diff(
base_partner_balance,
partner_values.get('balance', 0.0)))
values['partners_amounts'][
partner_id].update(partner_values)
account.comparisons = comp_accounts
all_partner_ids = reduce(add, [comp['partners_amounts'].keys() for comp in comp_accounts],
all_partner_ids = reduce(add, [comp['partners_amounts'].keys()
for comp in comp_accounts],
account.partners_amounts.keys())
account.partners_order = self._order_partners(all_partner_ids)

157
account_financial_report_webkit/report/common_partner_reports.py
View File

@ -30,10 +30,15 @@ from .common_reports import CommonReportHeaderWebkit
class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
"""Define common helper for partner oriented financial report"""
####################Account move line retrieval helper ##########################
def get_partners_move_lines_ids(self, account_id, main_filter, start, stop, target_move,
######################################
# Account move line retrieval helper #
######################################
def get_partners_move_lines_ids(self, account_id, main_filter, start, stop,
target_move,
exclude_reconcile=False,
partner_filter=False):
filter_from = False
@ -42,13 +47,10 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
elif main_filter == 'filter_date':
filter_from = 'date'
if filter_from:
return self._get_partners_move_line_ids(filter_from,
account_id,
start,
stop,
target_move,
exclude_reconcile=exclude_reconcile,
partner_filter=partner_filter)
return self._get_partners_move_line_ids(
filter_from, account_id, start, stop, target_move,
exclude_reconcile=exclude_reconcile,
partner_filter=partner_filter)
def _get_first_special_period(self):
"""
@ -59,8 +61,8 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
and it returns the id of the first period for which `special` is True
in this fiscal year.
It is used for example in the partners reports, where we have to include
the first, and only the first opening period.
It is used for example in the partners reports, where we have to
include the first, and only the first opening period.
:return: browse record of the first special period.
"""
@ -71,31 +73,36 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
# it may so
if not first_entry_id:
return
first_entry = move_line_obj.browse(self.cr, self.uid, first_entry_id[0])
first_entry = move_line_obj.browse(
self.cr, self.uid, first_entry_id[0])
fiscalyear = first_entry.period_id.fiscalyear_id
special_periods = [period for period in fiscalyear.period_ids if period.special]
special_periods = [
period for period in fiscalyear.period_ids if period.special]
# so, we have no opening period on the first year, nothing to return
if not special_periods:
return
return min(special_periods,
key=lambda p: datetime.strptime(p.date_start, DEFAULT_SERVER_DATE_FORMAT))
key=lambda p: datetime.strptime(p.date_start,
DEFAULT_SERVER_DATE_FORMAT))
def _get_period_range_from_start_period(self, start_period, include_opening=False,
def _get_period_range_from_start_period(self, start_period,
include_opening=False,
fiscalyear=False,
stop_at_previous_opening=False):
"""We retrieve all periods before start period"""
periods = super(CommonPartnersReportHeaderWebkit, self).\
_get_period_range_from_start_period(
start_period,
include_opening=include_opening,
fiscalyear=fiscalyear,
stop_at_previous_opening=stop_at_previous_opening)
_get_period_range_from_start_period(
start_period,
include_opening=include_opening,
fiscalyear=fiscalyear,
stop_at_previous_opening=stop_at_previous_opening)
first_special = self._get_first_special_period()
if first_special and first_special.id not in periods:
periods.append(first_special.id)
return periods
def _get_query_params_from_periods(self, period_start, period_stop, mode='exclude_opening'):
def _get_query_params_from_periods(self, period_start, period_stop,
mode='exclude_opening'):
"""
Build the part of the sql "where clause" which filters on the selected
periods.
@ -106,7 +113,7 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
"""
# we do not want opening period so we exclude opening
periods = self.pool.get('account.period').build_ctx_periods(
self.cr, self.uid, period_start.id, period_stop.id)
self.cr, self.uid, period_start.id, period_stop.id)
if not periods:
return []
@ -118,7 +125,8 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
sql_conditions = ""
if periods:
sql_conditions = " AND account_move_line.period_id in %(period_ids)s"
sql_conditions = " AND account_move_line.period_id in \
%(period_ids)s"
return sql_conditions, search_params
@ -138,14 +146,18 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
'date_start': date_start,
'date_stop': date_stop}
sql_conditions = " AND account_move_line.period_id not in %(period_ids)s" \
" AND account_move_line.date between date(%(date_start)s) and date((%(date_stop)s))"
sql_conditions = " AND account_move_line.period_id not \
in %(period_ids)s \
AND account_move_line.date between \
date(%(date_start)s) and date((%(date_stop)s))"
return sql_conditions, search_params
def _get_partners_move_line_ids(self, filter_from, account_id, start, stop,
target_move, opening_mode='exclude_opening',
exclude_reconcile=False, partner_filter=None):
target_move,
opening_mode='exclude_opening',
exclude_reconcile=False,
partner_filter=None):
"""
:param str filter_from: "periods" or "dates"
@ -162,7 +174,8 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
final_res = defaultdict(list)
sql_select = "SELECT account_move_line.id, account_move_line.partner_id FROM account_move_line"
sql_select = "SELECT account_move_line.id, \
account_move_line.partner_id FROM account_move_line"
sql_joins = ''
sql_where = " WHERE account_move_line.account_id = %(account_ids)s " \
" AND account_move_line.state = 'valid' "
@ -174,13 +187,17 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
if exclude_reconcile:
sql_where += (" AND ((account_move_line.reconcile_id IS NULL)"
" OR (account_move_line.reconcile_id IS NOT NULL AND account_move_line.last_rec_date > date(%(date_stop)s)))")
" OR (account_move_line.reconcile_id IS NOT NULL \
AND account_move_line.last_rec_date > \
date(%(date_stop)s)))")
if partner_filter:
sql_where += " AND account_move_line.partner_id in %(partner_ids)s"
sql_where += " AND account_move_line.partner_id \
in %(partner_ids)s"
if target_move == 'posted':
sql_joins += "INNER JOIN account_move ON account_move_line.move_id = account_move.id"
sql_joins += "INNER JOIN account_move \
ON account_move_line.move_id = account_move.id"
sql_where += " AND account_move.state = %(target_move)s"
search_params.update({'target_move': target_move})
@ -197,14 +214,16 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
final_res[row['partner_id']].append(row['id'])
return final_res
def _get_clearance_move_line_ids(self, move_line_ids, date_stop, date_until):
def _get_clearance_move_line_ids(self, move_line_ids, date_stop,
date_until):
if not move_line_ids:
return []
move_line_obj = self.pool.get('account.move.line')
# we do not use orm in order to gain perfo
# In this case I have to test the effective gain over an itteration
# Actually ORM does not allows distinct behavior
sql = "Select distinct reconcile_id from account_move_line where id in %s"
sql = "Select distinct reconcile_id from account_move_line \
where id in %s"
self.cursor.execute(sql, (tuple(move_line_ids),))
rec_ids = self.cursor.fetchall()
if rec_ids:
@ -218,7 +237,9 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
else:
return []
####################Initial Partner Balance helper ########################
##############################################
# Initial Partner Balance helper #
##############################################
def _tree_move_line_ids(self, move_lines_data, key=None):
"""
@ -243,19 +264,24 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
res[account_id][partner_id] = row
return res
def _partners_initial_balance_line_ids(self, account_ids, start_period, partner_filter, exclude_reconcile=False, force_period_ids=False, date_stop=None):
def _partners_initial_balance_line_ids(self, account_ids, start_period,
partner_filter,
exclude_reconcile=False,
force_period_ids=False,
date_stop=None):
# take ALL previous periods
period_ids = force_period_ids \
if force_period_ids \
else self._get_period_range_from_start_period(start_period, fiscalyear=False, include_opening=False)
if force_period_ids \
else self._get_period_range_from_start_period(
start_period, fiscalyear=False, include_opening=False)
if not period_ids:
period_ids = [-1]
search_param = {
'date_start': start_period.date_start,
'period_ids': tuple(period_ids),
'account_ids': tuple(account_ids),
}
'date_start': start_period.date_start,
'period_ids': tuple(period_ids),
'account_ids': tuple(account_ids),
}
sql = ("SELECT ml.id, ml.account_id, ml.partner_id "
"FROM account_move_line ml "
"INNER JOIN account_account a "
@ -264,10 +290,12 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
"AND ml.account_id in %(account_ids)s ")
if exclude_reconcile:
if not date_stop:
raise Exception("Missing \"date_stop\" to compute the open invoices.")
raise Exception(
"Missing \"date_stop\" to compute the open invoices.")
search_param.update({'date_stop': date_stop})
sql += ("AND ((ml.reconcile_id IS NULL)"
"OR (ml.reconcile_id IS NOT NULL AND ml.last_rec_date > date(%(date_stop)s))) ")
sql += ("AND ((ml.reconcile_id IS NULL) "
"OR (ml.reconcile_id IS NOT NULL \
AND ml.last_rec_date > date(%(date_stop)s))) ")
if partner_filter:
sql += "AND ml.partner_id in %(partner_ids)s "
search_param.update({'partner_ids': tuple(partner_filter)})
@ -275,21 +303,28 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
self.cursor.execute(sql, search_param)
return self.cursor.dictfetchall()
def _compute_partners_initial_balances(self, account_ids, start_period, partner_filter=None, exclude_reconcile=False, force_period_ids=False):
def _compute_partners_initial_balances(self, account_ids, start_period,
partner_filter=None,
exclude_reconcile=False,
force_period_ids=False):
"""We compute initial balance.
If form is filtered by date all initial balance are equal to 0
This function will sum pear and apple in currency amount if account as no secondary currency"""
This function will sum pear and apple in currency amount if account
as no secondary currency"""
if isinstance(account_ids, (int, long)):
account_ids = [account_ids]
move_line_ids = self._partners_initial_balance_line_ids(account_ids, start_period, partner_filter,
exclude_reconcile=exclude_reconcile,
force_period_ids=force_period_ids)
move_line_ids = self._partners_initial_balance_line_ids(
account_ids, start_period, partner_filter,
exclude_reconcile=exclude_reconcile,
force_period_ids=force_period_ids)
if not move_line_ids:
move_line_ids = [{'id': -1}]
sql = ("SELECT ml.account_id, ml.partner_id,"
" sum(ml.debit) as debit, sum(ml.credit) as credit,"
" sum(ml.debit-ml.credit) as init_balance,"
" CASE WHEN a.currency_id ISNULL THEN 0.0 ELSE sum(ml.amount_currency) END as init_balance_currency, "
" CASE WHEN a.currency_id ISNULL THEN 0.0\
ELSE sum(ml.amount_currency) \
END as init_balance_currency, "
" c.name as currency_name "
"FROM account_move_line ml "
"INNER JOIN account_account a "
@ -298,12 +333,17 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
"ON c.id = a.currency_id "
"WHERE ml.id in %(move_line_ids)s "
"GROUP BY ml.account_id, ml.partner_id, a.currency_id, c.name")
search_param = {'move_line_ids': tuple([move_line['id'] for move_line in move_line_ids])}
search_param = {
'move_line_ids': tuple([move_line['id'] for move_line in
move_line_ids])}
self.cursor.execute(sql, search_param)
res = self.cursor.dictfetchall()
return self._tree_move_line_ids(res)
####################Partner specific helper ################################
############################################################
# Partner specific helper #
############################################################
def _order_partners(self, *args):
"""We get the partner linked to all current accounts that are used.
We also use ensure that partner are ordered by name
@ -316,11 +356,16 @@ class CommonPartnersReportHeaderWebkit(CommonReportHeaderWebkit):
if not partner_ids:
return []
existing_partner_ids = [partner_id for partner_id in partner_ids if partner_id]
existing_partner_ids = [
partner_id for partner_id in partner_ids if partner_id]
if existing_partner_ids:
# We may use orm here as the performance optimization is not that big
sql = ("SELECT name|| ' ' ||CASE WHEN ref IS NOT NULL THEN '('||ref||')' ELSE '' END, id, ref, name"
" FROM res_partner WHERE id IN %s ORDER BY LOWER(name), ref")
# We may use orm here as the performance optimization is not that
# big
sql = ("SELECT name|| ' ' ||CASE WHEN ref IS NOT NULL \
THEN '('||ref||')' \
ELSE '' END, id, ref, name"
" FROM res_partner \
WHERE id IN %s ORDER BY LOWER(name), ref")
self.cursor.execute(sql, (tuple(set(existing_partner_ids)),))
res = self.cursor.fetchall()

227
account_financial_report_webkit/report/common_reports.py
View File

@ -26,15 +26,22 @@ import logging
from openerp.osv import osv
from openerp.tools.translate import _
from openerp.addons.account.report.common_report_header import common_report_header
from openerp.addons.account.report.common_report_header \
import common_report_header
_logger = logging.getLogger('financial.reports.webkit')
MAX_MONSTER_SLICE = 50000
class CommonReportHeaderWebkit(common_report_header):
"""Define common helper for financial report"""
####################From getter helper #####################################
######################################################################
# From getter helper #
######################################################################
def get_start_period_br(self, data):
return self._get_info(data, 'period_from', 'account.period')
@ -112,20 +119,26 @@ class CommonReportHeaderWebkit(common_report_header):
def _get_form_param(self, param, data, default=False):
return data.get('form', {}).get(param, default)
####################Account and account line filter helper #################
#############################################
# Account and account line filter helper #
#############################################
def sort_accounts_with_structure(self, root_account_ids, account_ids, context=None):
def sort_accounts_with_structure(self, root_account_ids, account_ids,
context=None):
"""Sort accounts by code respecting their structure"""
def recursive_sort_by_code(accounts, parent):
sorted_accounts = []
# add all accounts with same parent
level_accounts = [account for account in accounts
if account['parent_id'] and account['parent_id'][0] == parent['id']]
# add consolidation children of parent, as they are logically on the same level
if account['parent_id']
and account['parent_id'][0] == parent['id']]
# add consolidation children of parent, as they are logically on
# the same level
if parent.get('child_consol_ids'):
level_accounts.extend([account for account in accounts
if account['id'] in parent['child_consol_ids']])
if account['id']
in parent['child_consol_ids']])
# stop recursion if no children found
if not level_accounts:
return []
@ -134,16 +147,17 @@ class CommonReportHeaderWebkit(common_report_header):
for level_account in level_accounts:
sorted_accounts.append(level_account['id'])
sorted_accounts.extend(recursive_sort_by_code(accounts, parent=level_account))
sorted_accounts.extend(
recursive_sort_by_code(accounts, parent=level_account))
return sorted_accounts
if not account_ids:
return []
accounts_data = self.pool.get('account.account').read(self.cr, self.uid,
account_ids,
['id', 'parent_id', 'level', 'code', 'child_consol_ids'],
context=context)
accounts_data = self.pool.get('account.account').read(
self.cr, self.uid, account_ids,
['id', 'parent_id', 'level', 'code', 'child_consol_ids'],
context=context)
sorted_accounts = []
@ -151,7 +165,8 @@ class CommonReportHeaderWebkit(common_report_header):
if account_data['id'] in root_account_ids]
for root_account_data in root_accounts_data:
sorted_accounts.append(root_account_data['id'])
sorted_accounts.extend(recursive_sort_by_code(accounts_data, root_account_data))
sorted_accounts.extend(
recursive_sort_by_code(accounts_data, root_account_data))
# fallback to unsorted accounts when sort failed
# sort fails when the levels are miscalculated by account.account
@ -162,11 +177,14 @@ class CommonReportHeaderWebkit(common_report_header):
return sorted_accounts
def get_all_accounts(self, account_ids, exclude_type=None, only_type=None, filter_report_type=None, context=None):
def get_all_accounts(self, account_ids, exclude_type=None, only_type=None,
filter_report_type=None, context=None):
"""Get all account passed in params with their childrens
@param exclude_type: list of types to exclude (view, receivable, payable, consolidation, other)
@param only_type: list of types to filter on (view, receivable, payable, consolidation, other)
@param exclude_type: list of types to exclude (view, receivable,
payable, consolidation, other)
@param only_type: list of types to filter on (view, receivable,
payable, consolidation, other)
@param filter_report_type: list of report type to filter on
"""
context = context or {}
@ -176,9 +194,11 @@ class CommonReportHeaderWebkit(common_report_header):
acc_obj = self.pool.get('account.account')
for account_id in account_ids:
accounts.append(account_id)
accounts += acc_obj._get_children_and_consol(self.cursor, self.uid, account_id, context=context)
accounts += acc_obj._get_children_and_consol(
self.cursor, self.uid, account_id, context=context)
res_ids = list(set(accounts))
res_ids = self.sort_accounts_with_structure(account_ids, res_ids, context=context)
res_ids = self.sort_accounts_with_structure(
account_ids, res_ids, context=context)
if exclude_type or only_type or filter_report_type:
sql_filters = {'ids': tuple(res_ids)}
@ -207,17 +227,22 @@ class CommonReportHeaderWebkit(common_report_header):
res_ids = [res_id for res_id in res_ids if res_id in only_ids]
return res_ids
####################Periods and fiscal years helper #######################
##########################################
# Periods and fiscal years helper #
##########################################
def _get_opening_periods(self):
"""Return the list of all journal that can be use to create opening entries
We actually filter on this instead of opening period as older version of OpenERP
did not have this notion"""
return self.pool.get('account.period').search(self.cursor, self.uid, [('special', '=', True)])
"""Return the list of all journal that can be use to create opening
entries.
We actually filter on this instead of opening period as older version
of OpenERP did not have this notion"""
return self.pool.get('account.period').search(self.cursor, self.uid,
[('special', '=', True)])
def exclude_opening_periods(self, period_ids):
period_obj = self.pool.get('account.period')
return period_obj.search(self.cr, self.uid, [['special', '=', False], ['id', 'in', period_ids]])
return period_obj.search(self.cr, self.uid, [['special', '=', False],
['id', 'in', period_ids]])
def get_included_opening_period(self, period):
"""Return the opening included in normal period we use the assumption
@ -228,7 +253,7 @@ class CommonReportHeaderWebkit(common_report_header):
('date_start', '>=', period.date_start),
('date_stop', '<=', period.date_stop),
('company_id', '=', period.company_id.id)],
limit=1)
limit=1)
def periods_contains_move_lines(self, period_ids):
if not period_ids:
@ -236,12 +261,16 @@ class CommonReportHeaderWebkit(common_report_header):
mv_line_obj = self.pool.get('account.move.line')
if isinstance(period_ids, (int, long)):
period_ids = [period_ids]
return mv_line_obj.search(self.cursor, self.uid, [('period_id', 'in', period_ids)], limit=1) and True or False
return mv_line_obj.search(self.cursor, self.uid,
[('period_id', 'in', period_ids)], limit=1) \
and True or False
def _get_period_range_from_periods(self, start_period, stop_period, mode=None):
def _get_period_range_from_periods(self, start_period, stop_period,
mode=None):
"""
Deprecated. We have to use now the build_ctx_periods of period_obj otherwise we'll have
inconsistencies, because build_ctx_periods does never filter on the the special
Deprecated. We have to use now the build_ctx_periods of period_obj
otherwise we'll have inconsistencies, because build_ctx_periods does
never filter on the the special
"""
period_obj = self.pool.get('account.period')
search_period = [('date_start', '>=', start_period.date_start),
@ -252,8 +281,10 @@ class CommonReportHeaderWebkit(common_report_header):
res = period_obj.search(self.cursor, self.uid, search_period)
return res
def _get_period_range_from_start_period(self, start_period, include_opening=False,
fiscalyear=False, stop_at_previous_opening=False):
def _get_period_range_from_start_period(self, start_period,
include_opening=False,
fiscalyear=False,
stop_at_previous_opening=False):
"""We retrieve all periods before start period"""
opening_period_id = False
past_limit = []
@ -262,24 +293,28 @@ class CommonReportHeaderWebkit(common_report_header):
# We look for previous opening period
if stop_at_previous_opening:
opening_search = [('special', '=', True),
('date_stop', '<', start_period.date_start)]
('date_stop', '<', start_period.date_start)]
if fiscalyear:
opening_search.append(('fiscalyear_id', '=', fiscalyear.id))
opening_periods = period_obj.search(self.cursor, self.uid, opening_search,
opening_periods = period_obj.search(self.cursor, self.uid,
opening_search,
order='date_stop desc')
for opening_period in opening_periods:
validation_res = mv_line_obj.search(self.cursor,
self.uid,
[('period_id', '=', opening_period)],
[('period_id', '=',
opening_period)],
limit=1)
if validation_res:
opening_period_id = opening_period
break
if opening_period_id:
#we also look for overlapping periods
opening_period_br = period_obj.browse(self.cursor, self.uid, opening_period_id)
past_limit = [('date_start', '>=', opening_period_br.date_stop)]
# we also look for overlapping periods
opening_period_br = period_obj.browse(
self.cursor, self.uid, opening_period_id)
past_limit = [
('date_start', '>=', opening_period_br.date_stop)]
periods_search = [('date_stop', '<=', start_period.date_stop)]
periods_search += past_limit
@ -303,7 +338,8 @@ class CommonReportHeaderWebkit(common_report_header):
def get_last_fiscalyear_period(self, fiscalyear):
return self._get_st_fiscalyear_period(fiscalyear, order='DESC')
def _get_st_fiscalyear_period(self, fiscalyear, special=False, order='ASC'):
def _get_st_fiscalyear_period(self, fiscalyear, special=False,
order='ASC'):
period_obj = self.pool.get('account.period')
p_id = period_obj.search(self.cursor,
self.uid,
@ -315,9 +351,12 @@ class CommonReportHeaderWebkit(common_report_header):
raise osv.except_osv(_('No period found'), '')
return period_obj.browse(self.cursor, self.uid, p_id[0])
####################Initial Balance helper #################################
###############################
# Initial Balance helper #
###############################
def _compute_init_balance(self, account_id=None, period_ids=None, mode='computed', default_values=False):
def _compute_init_balance(self, account_id=None, period_ids=None,
mode='computed', default_values=False):
if not isinstance(period_ids, list):
period_ids = [period_ids]
res = {}
@ -332,7 +371,8 @@ class CommonReportHeaderWebkit(common_report_header):
" sum(amount_currency) AS curr_balance"
" FROM account_move_line"
" WHERE period_id in %s"
" AND account_id = %s", (tuple(period_ids), account_id))
" AND account_id = %s",
(tuple(period_ids), account_id))
res = self.cursor.dictfetchone()
except Exception, exc:
@ -348,67 +388,81 @@ class CommonReportHeaderWebkit(common_report_header):
def _read_opening_balance(self, account_ids, start_period):
""" Read opening balances from the opening balance
"""
opening_period_selected = self.get_included_opening_period(start_period)
opening_period_selected = self.get_included_opening_period(
start_period)
if not opening_period_selected:
raise osv.except_osv(
_('Error'),
_('No opening period found to compute the opening balances.\n'
'You have to configure a period on the first of January'
' with the special flag.'))
_('Error'),
_('No opening period found to compute the opening balances.\n'
'You have to configure a period on the first of January'
' with the special flag.'))
res = {}
for account_id in account_ids:
res[account_id] = self._compute_init_balance(account_id, opening_period_selected, mode='read')
res[account_id] = self._compute_init_balance(
account_id, opening_period_selected, mode='read')
return res
def _compute_initial_balances(self, account_ids, start_period, fiscalyear):
"""We compute initial balance.
If form is filtered by date all initial balance are equal to 0
This function will sum pear and apple in currency amount if account as no secondary currency"""
# if opening period is included in start period we do not need to compute init balance
# we just read it from opening entries
This function will sum pear and apple in currency amount if account as
no secondary currency"""
# if opening period is included in start period we do not need to
# compute init balance we just read it from opening entries
res = {}
# PNL and Balance accounts are not computed the same way look for attached doc
# We include opening period in pnl account in order to see if opening entries
# were created by error on this account
pnl_periods_ids = self._get_period_range_from_start_period(start_period, fiscalyear=fiscalyear,
include_opening=True)
bs_period_ids = self._get_period_range_from_start_period(start_period, include_opening=True,
stop_at_previous_opening=True)
opening_period_selected = self.get_included_opening_period(start_period)
# PNL and Balance accounts are not computed the same way look for
# attached doc We include opening period in pnl account in order to see
# if opening entries were created by error on this account
pnl_periods_ids = self._get_period_range_from_start_period(
start_period, fiscalyear=fiscalyear, include_opening=True)
bs_period_ids = self._get_period_range_from_start_period(
start_period, include_opening=True, stop_at_previous_opening=True)
opening_period_selected = self.get_included_opening_period(
start_period)
for acc in self.pool.get('account.account').browse(self.cursor, self.uid, account_ids):
for acc in self.pool.get('account.account').browse(self.cursor,
self.uid,
account_ids):
res[acc.id] = self._compute_init_balance(default_values=True)
if acc.user_type.close_method == 'none':
# we compute the initial balance for close_method == none only when we print a GL
# during the year, when the opening period is not included in the period selection!
# we compute the initial balance for close_method == none only
# when we print a GL during the year, when the opening period
# is not included in the period selection!
if pnl_periods_ids and not opening_period_selected:
res[acc.id] = self._compute_init_balance(acc.id, pnl_periods_ids)
res[acc.id] = self._compute_init_balance(
acc.id, pnl_periods_ids)
else:
res[acc.id] = self._compute_init_balance(acc.id, bs_period_ids)
return res
####################Account move retrieval helper ##########################
def _get_move_ids_from_periods(self, account_id, period_start, period_stop, target_move):
################################################
# Account move retrieval helper #
################################################
def _get_move_ids_from_periods(self, account_id, period_start, period_stop,
target_move):
move_line_obj = self.pool.get('account.move.line')
period_obj = self.pool.get('account.period')
periods = period_obj.build_ctx_periods(self.cursor, self.uid, period_start.id, period_stop.id)
periods = period_obj.build_ctx_periods(
self.cursor, self.uid, period_start.id, period_stop.id)
if not periods:
return []
search = [('period_id', 'in', periods), ('account_id', '=', account_id)]
search = [
('period_id', 'in', periods), ('account_id', '=', account_id)]
if target_move == 'posted':
search += [('move_id.state', '=', 'posted')]
return move_line_obj.search(self.cursor, self.uid, search)
def _get_move_ids_from_dates(self, account_id, date_start, date_stop, target_move, mode='include_opening'):
def _get_move_ids_from_dates(self, account_id, date_start, date_stop,
target_move, mode='include_opening'):
# TODO imporve perfomance by setting opening period as a property
move_line_obj = self.pool.get('account.move.line')
search_period = [('date', '>=', date_start),
('date', '<=', date_stop),
('account_id', '=', account_id)]
# actually not used because OpenERP itself always include the opening when we
# get the periods from january to december
# actually not used because OpenERP itself always include the opening
# when we get the periods from january to december
if mode == 'exclude_opening':
opening = self._get_opening_periods()
if opening:
@ -419,20 +473,28 @@ class CommonReportHeaderWebkit(common_report_header):
return move_line_obj.search(self.cursor, self.uid, search_period)
def get_move_lines_ids(self, account_id, main_filter, start, stop, target_move, mode='include_opening'):
def get_move_lines_ids(self, account_id, main_filter, start, stop,
target_move, mode='include_opening'):
"""Get account move lines base on form data"""
if mode not in ('include_opening', 'exclude_opening'):
raise osv.except_osv(_('Invalid query mode'), _('Must be in include_opening, exclude_opening'))
raise osv.except_osv(
_('Invalid query mode'),
_('Must be in include_opening, exclude_opening'))
if main_filter in ('filter_period', 'filter_no'):
return self._get_move_ids_from_periods(account_id, start, stop, target_move)
return self._get_move_ids_from_periods(account_id, start, stop,
target_move)
elif main_filter == 'filter_date':
return self._get_move_ids_from_dates(account_id, start, stop, target_move)
return self._get_move_ids_from_dates(account_id, start, stop,
target_move)
else:
raise osv.except_osv(_('No valid filter'), _('Please set a valid time filter'))
raise osv.except_osv(
_('No valid filter'), _('Please set a valid time filter'))
def _get_move_line_datas(self, move_line_ids, order='per.special DESC, l.date ASC, per.date_start ASC, m.name ASC'):
def _get_move_line_datas(self, move_line_ids,
order='per.special DESC, l.date ASC, \
per.date_start ASC, m.name ASC'):
# Possible bang if move_line_ids is too long
# We can not slice here as we have to do the sort.
# If slice has to be done it means that we have to reorder in python
@ -475,7 +537,8 @@ SELECT l.id AS id,
FROM account_move_line l
JOIN account_move m on (l.move_id=m.id)
LEFT JOIN res_currency c on (l.currency_id=c.id)
LEFT JOIN account_move_reconcile partialrec on (l.reconcile_partial_id = partialrec.id)
LEFT JOIN account_move_reconcile partialrec
on (l.reconcile_partial_id = partialrec.id)
LEFT JOIN account_move_reconcile fullrec on (l.reconcile_id = fullrec.id)
LEFT JOIN res_partner p on (l.partner_id=p.id)
LEFT JOIN account_invoice i on (m.id =i.move_id)
@ -506,8 +569,10 @@ SELECT account_move.id,
AND m2.account_id<>%s limit %s) , ', ')
FROM account_move
JOIN account_move_line on (account_move_line.move_id = account_move.id)
JOIN account_account on (account_move_line.account_id = account_account.id)
JOIN account_move_line
on (account_move_line.move_id = account_move.id)
JOIN account_account
on (account_move_line.account_id = account_account.id)
WHERE move_id in %s"""
try:
@ -524,8 +589,10 @@ WHERE move_id in %s"""
return True
def _get_initial_balance_mode(self, start_period):
opening_period_selected = self.get_included_opening_period(start_period)
opening_move_lines = self.periods_contains_move_lines(opening_period_selected)
opening_period_selected = self.get_included_opening_period(
start_period)
opening_move_lines = self.periods_contains_move_lines(
opening_period_selected)
if opening_move_lines:
return 'opening_balance'
else:

101
account_financial_report_webkit/report/general_ledger.py
View File

@ -33,14 +33,18 @@ from .webkit_parser_header_fix import HeaderFooterTextWebKitParser
class GeneralLedgerWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
def __init__(self, cursor, uid, name, context):
super(GeneralLedgerWebkit, self).__init__(cursor, uid, name, context=context)
super(GeneralLedgerWebkit, self).__init__(
cursor, uid, name, context=context)
self.pool = pooler.get_pool(self.cr.dbname)
self.cursor = self.cr
company = self.pool.get('res.users').browse(self.cr, uid, uid, context=context).company_id
header_report_name = ' - '.join((_('GENERAL LEDGER'), company.name, company.currency_id.name))
company = self.pool.get('res.users').browse(
self.cr, uid, uid, context=context).company_id
header_report_name = ' - '.join(
(_('GENERAL LEDGER'), company.name, company.currency_id.name))
footer_date_time = self.formatLang(str(datetime.today()), date_time=True)
footer_date_time = self.formatLang(
str(datetime.today()), date_time=True)
self.localcontext.update({
'cr': cursor,
@ -62,15 +66,17 @@ class GeneralLedgerWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
('--header-left', header_report_name),
('--header-spacing', '2'),
('--footer-left', footer_date_time),
('--footer-right', ' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-right',
' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-line',),
],
})
def set_context(self, objects, data, ids, report_type=None):
"""Populate a ledger_lines attribute on each browse record that will be used
by mako template"""
new_ids = data['form']['account_ids'] or data['form']['chart_account_id']
"""Populate a ledger_lines attribute on each browse record that will be
used by mako template"""
new_ids = data['form']['account_ids'] or data[
'form']['chart_account_id']
# Account initial balance memoizer
init_balance_memoizer = {}
@ -99,23 +105,31 @@ class GeneralLedgerWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
stop = stop_period
initial_balance = self.is_initial_balance_enabled(main_filter)
initial_balance_mode = initial_balance and self._get_initial_balance_mode(start) or False
initial_balance_mode = initial_balance \
and self._get_initial_balance_mode(start) or False
# Retrieving accounts
accounts = self.get_all_accounts(new_ids, exclude_type=['view'])
if initial_balance_mode == 'initial_balance':
init_balance_memoizer = self._compute_initial_balances(accounts, start, fiscalyear)
init_balance_memoizer = self._compute_initial_balances(
accounts, start, fiscalyear)
elif initial_balance_mode == 'opening_balance':
init_balance_memoizer = self._read_opening_balance(accounts, start)
ledger_lines_memoizer = self._compute_account_ledger_lines(accounts, init_balance_memoizer,
main_filter, target_move, start, stop)
ledger_lines_memoizer = self._compute_account_ledger_lines(
accounts, init_balance_memoizer, main_filter, target_move, start,
stop)
objects = []
for account in self.pool.get('account.account').browse(self.cursor, self.uid, accounts):
if do_centralize and account.centralized and ledger_lines_memoizer.get(account.id):
account.ledger_lines = self._centralize_lines(main_filter, ledger_lines_memoizer.get(account.id, []))
for account in self.pool.get('account.account').browse(self.cursor,
self.uid,
accounts):
if do_centralize and account.centralized \
and ledger_lines_memoizer.get(account.id):
account.ledger_lines = self._centralize_lines(
main_filter, ledger_lines_memoizer.get(account.id, []))
else:
account.ledger_lines = ledger_lines_memoizer.get(account.id, [])
account.ledger_lines = ledger_lines_memoizer.get(
account.id, [])
account.init_balance = init_balance_memoizer.get(account.id, {})
objects.append(account)
@ -130,17 +144,20 @@ class GeneralLedgerWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
'initial_balance_mode': initial_balance_mode,
})
return super(GeneralLedgerWebkit, self).set_context(objects, data, new_ids,
report_type=report_type)
return super(GeneralLedgerWebkit, self).set_context(
objects, data, new_ids, report_type=report_type)
def _centralize_lines(self, filter, ledger_lines, context=None):
""" Group by period in filter mode 'period' or on one line in filter mode 'date'
ledger_lines parameter is a list of dict built by _get_ledger_lines"""
""" Group by period in filter mode 'period' or on one line in filter
mode 'date' ledger_lines parameter is a list of dict built
by _get_ledger_lines"""
def group_lines(lines):
if not lines:
return {}
sums = reduce(lambda line, memo: dict((key, value + memo[key]) for key, value
in line.iteritems() if key in ('balance', 'debit', 'credit')), lines)
sums = reduce(lambda line, memo:
dict((key, value + memo[key]) for key, value
in line.iteritems() if key in
('balance', 'debit', 'credit')), lines)
res_lines = {
'balance': sums['balance'],
@ -161,32 +178,38 @@ class GeneralLedgerWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
period_obj = self.pool.get('account.period')
# we need to sort the lines per period in order to use groupby
# unique ids of each used period id in lines
period_ids = list(set([line['lperiod_id'] for line in ledger_lines]))
period_ids = list(
set([line['lperiod_id'] for line in ledger_lines]))
# search on account.period in order to sort them by date_start
sorted_period_ids = period_obj.search(self.cr, self.uid,
[('id', 'in', period_ids)],
order='special desc, date_start',
context=context)
sorted_ledger_lines = sorted(ledger_lines, key=lambda x: sorted_period_ids.index(x['lperiod_id']))
sorted_period_ids = period_obj.search(
self.cr, self.uid, [('id', 'in', period_ids)],
order='special desc, date_start', context=context)
sorted_ledger_lines = sorted(
ledger_lines, key=lambda x: sorted_period_ids.
index(x['lperiod_id']))
for period_id, lines_per_period_iterator in groupby(sorted_ledger_lines, itemgetter('lperiod_id')):
for period_id, lines_per_period_iterator in groupby(
sorted_ledger_lines, itemgetter('lperiod_id')):
lines_per_period = list(lines_per_period_iterator)
if not lines_per_period:
continue
group_per_period = group_lines(lines_per_period)
group_per_period.update({
'lperiod_id': period_id,
'period_code': lines_per_period[0]['period_code'], # period code is anyway the same on each line per period
# period code is anyway the same on each line per period
'period_code': lines_per_period[0]['period_code'],
})
centralized_lines.append(group_per_period)
return centralized_lines
def _compute_account_ledger_lines(self, accounts_ids, init_balance_memoizer, main_filter,
def _compute_account_ledger_lines(self, accounts_ids,
init_balance_memoizer, main_filter,
target_move, start, stop):
res = {}
for acc_id in accounts_ids:
move_line_ids = self.get_move_lines_ids(acc_id, main_filter, start, stop, target_move)
move_line_ids = self.get_move_lines_ids(
acc_id, main_filter, start, stop, target_move)
if not move_line_ids:
res[acc_id] = []
continue
@ -199,8 +222,8 @@ class GeneralLedgerWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
if not move_line_ids:
return []
res = self._get_move_line_datas(move_line_ids)
## computing counter part is really heavy in term of ressouces consuption
## looking for a king of SQL to help me improve it
# computing counter part is really heavy in term of ressouces
# consuption looking for a king of SQL to help me improve it
move_ids = [x.get('move_id') for x in res]
counter_parts = self._get_moves_counterparts(move_ids, account_id)
for line in res:
@ -208,7 +231,9 @@ class GeneralLedgerWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
return res
HeaderFooterTextWebKitParser('report.account.account_report_general_ledger_webkit',
'account.account',
'addons/account_financial_report_webkit/report/templates/account_report_general_ledger.mako',
parser=GeneralLedgerWebkit)
HeaderFooterTextWebKitParser(
'report.account.account_report_general_ledger_webkit',
'account.account',
'addons/account_financial_report_webkit/report/templates/\
account_report_general_ledger.mako',
parser=GeneralLedgerWebkit)

120
account_financial_report_webkit/report/open_invoices.py
View File

@ -43,17 +43,23 @@ def get_mako_template(obj, *args):
report_helper.WebKitHelper.get_mako_template = get_mako_template
class PartnersOpenInvoicesWebkit(report_sxw.rml_parse, CommonPartnersReportHeaderWebkit):
class PartnersOpenInvoicesWebkit(report_sxw.rml_parse,
CommonPartnersReportHeaderWebkit):
def __init__(self, cursor, uid, name, context):
super(PartnersOpenInvoicesWebkit, self).__init__(cursor, uid, name, context=context)
super(PartnersOpenInvoicesWebkit, self).__init__(
cursor, uid, name, context=context)
self.pool = pooler.get_pool(self.cr.dbname)
self.cursor = self.cr
company = self.pool.get('res.users').browse(self.cr, uid, uid, context=context).company_id
header_report_name = ' - '.join((_('OPEN INVOICES REPORT'), company.name, company.currency_id.name))
company = self.pool.get('res.users').browse(
self.cr, uid, uid, context=context).company_id
header_report_name = ' - '.join((_('OPEN INVOICES REPORT'),
company.name,
company.currency_id.name))
footer_date_time = self.formatLang(str(datetime.today()), date_time=True)
footer_date_time = self.formatLang(
str(datetime.today()), date_time=True)
self.localcontext.update({
'cr': cursor,
@ -73,7 +79,8 @@ class PartnersOpenInvoicesWebkit(report_sxw.rml_parse, CommonPartnersReportHeade
('--header-left', header_report_name),
('--header-spacing', '2'),
('--footer-left', footer_date_time),
('--footer-right', ' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-right',
' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-line',),
],
})
@ -85,13 +92,15 @@ class PartnersOpenInvoicesWebkit(report_sxw.rml_parse, CommonPartnersReportHeade
for part_id, plane_lines in account_br.ledger_lines.items():
account_br.grouped_ledger_lines[part_id] = []
plane_lines.sort(key=itemgetter('currency_code'))
for curr, lines in groupby(plane_lines, key=itemgetter('currency_code')):
for curr, lines in groupby(plane_lines,
key=itemgetter('currency_code')):
tmp = [x for x in lines]
account_br.grouped_ledger_lines[part_id].append((curr, tmp)) # I want to reiter many times
account_br.grouped_ledger_lines[part_id].append(
(curr, tmp)) # I want to reiter many times
def set_context(self, objects, data, ids, report_type=None):
"""Populate a ledger_lines attribute on each browse record that will be used
by mako template"""
"""Populate a ledger_lines attribute on each browse record that will
be used by mako template"""
new_ids = data['form']['chart_account_id']
# Account initial balance memoizer
init_balance_memoizer = {}
@ -120,7 +129,8 @@ class PartnersOpenInvoicesWebkit(report_sxw.rml_parse, CommonPartnersReportHeade
if result_selection == 'supplier':
filter_type = ('payable',)
account_ids = self.get_all_accounts(new_ids, exclude_type=['view'], only_type=filter_type)
account_ids = self.get_all_accounts(
new_ids, exclude_type=['view'], only_type=filter_type)
if not account_ids:
raise osv.except_osv(_('Error'), _('No accounts to print.'))
@ -132,26 +142,28 @@ class PartnersOpenInvoicesWebkit(report_sxw.rml_parse, CommonPartnersReportHeade
else:
start = start_period
stop = stop_period
ledger_lines_memoizer = self._compute_open_transactions_lines(account_ids,
main_filter,
target_move,
start,
stop,
date_until,
partner_filter=partner_ids)
ledger_lines_memoizer = self._compute_open_transactions_lines(
account_ids, main_filter, target_move, start, stop, date_until,
partner_filter=partner_ids)
objects = []
for account in self.pool.get('account.account').browse(self.cursor, self.uid, account_ids):
for account in self.pool.get('account.account').browse(self.cursor,
self.uid,
account_ids):
account.ledger_lines = ledger_lines_memoizer.get(account.id, {})
account.init_balance = init_balance_memoizer.get(account.id, {})
## we have to compute partner order based on inital balance
## and ledger line as we may have partner with init bal
## that are not in ledger line and vice versa
# we have to compute partner order based on inital balance
# and ledger line as we may have partner with init bal
# that are not in ledger line and vice versa
ledg_lines_pids = ledger_lines_memoizer.get(account.id, {}).keys()
non_null_init_balances = dict([(ib, amounts) for ib, amounts in account.init_balance.iteritems()
if amounts['init_balance'] or amounts['init_balance_currency']])
non_null_init_balances = dict([
(ib, amounts) for ib, amounts
in account.init_balance.iteritems()
if amounts['init_balance']
or amounts['init_balance_currency']])
init_bal_lines_pids = non_null_init_balances.keys()
account.partners_order = self._order_partners(ledg_lines_pids, init_bal_lines_pids)
account.partners_order = self._order_partners(
ledg_lines_pids, init_bal_lines_pids)
account.ledger_lines = ledger_lines_memoizer.get(account.id, {})
if group_by_currency:
self._group_lines_by_currency(account)
@ -168,13 +180,16 @@ class PartnersOpenInvoicesWebkit(report_sxw.rml_parse, CommonPartnersReportHeade
'chart_account': chart_account,
})
return super(PartnersOpenInvoicesWebkit, self).set_context(objects, data, new_ids,
report_type=report_type)
return super(PartnersOpenInvoicesWebkit, self).set_context(
objects, data, new_ids, report_type=report_type)
def _compute_open_transactions_lines(self, accounts_ids, main_filter, target_move, start, stop, date_until=False, partner_filter=False):
def _compute_open_transactions_lines(self, accounts_ids, main_filter,
target_move, start, stop,
date_until=False,
partner_filter=False):
res = defaultdict(dict)
## we check if until date and date stop have the same value
# we check if until date and date stop have the same value
if main_filter in ('filter_period', 'filter_no'):
date_stop = stop.date_stop
date_until_match = (date_stop == date_until)
@ -185,7 +200,8 @@ class PartnersOpenInvoicesWebkit(report_sxw.rml_parse, CommonPartnersReportHeade
else:
raise osv.except_osv(_('Unsuported filter'),
_('Filter has to be in filter date, period, or none'))
_('Filter has to be in filter date, period, \
or none'))
initial_move_lines_per_account = {}
if main_filter in ('filter_period', 'filter_no'):
@ -195,34 +211,38 @@ class PartnersOpenInvoicesWebkit(report_sxw.rml_parse, CommonPartnersReportHeade
partner_filter,
exclude_reconcile=True,
force_period_ids=False,
date_stop=date_stop), key='id')
date_stop=date_stop),
key='id')
for account_id in accounts_ids:
initial_move_lines_ids_per_partner = initial_move_lines_per_account.get(account_id, {})
initial_move_lines_ids_per_partner = \
initial_move_lines_per_account.get(account_id, {})
# We get the move line ids of the account
move_line_ids_per_partner = self.get_partners_move_lines_ids(account_id,
main_filter,
start,
stop,
target_move,
exclude_reconcile=True,
partner_filter=partner_filter)
move_line_ids_per_partner = self.get_partners_move_lines_ids(
account_id, main_filter, start, stop, target_move,
exclude_reconcile=True, partner_filter=partner_filter)
if not initial_move_lines_ids_per_partner and not move_line_ids_per_partner:
if not initial_move_lines_ids_per_partner \
and not move_line_ids_per_partner:
continue
for partner_id in list(set(initial_move_lines_ids_per_partner.keys() + move_line_ids_per_partner.keys())):
partner_line_ids = (move_line_ids_per_partner.get(partner_id, []) +
initial_move_lines_ids_per_partner.get(partner_id, []))
for partner_id in list(
set(initial_move_lines_ids_per_partner.keys() +
move_line_ids_per_partner.keys())):
partner_line_ids = (
move_line_ids_per_partner.get(partner_id, []) +
initial_move_lines_ids_per_partner.get(partner_id, []))
clearance_line_ids = []
if date_until and not date_until_match and partner_line_ids:
clearance_line_ids = self._get_clearance_move_line_ids(partner_line_ids, date_stop, date_until)
clearance_line_ids = self._get_clearance_move_line_ids(
partner_line_ids, date_stop, date_until)
partner_line_ids += clearance_line_ids
lines = self._get_move_line_datas(list(set(partner_line_ids)))
for line in lines:
if line['id'] in initial_move_lines_ids_per_partner.get(partner_id, []):
if line['id'] in initial_move_lines_ids_per_partner.\
get(partner_id, []):
line['is_from_previous_periods'] = True
if line['id'] in clearance_line_ids:
line['is_clearance_line'] = True
@ -231,7 +251,9 @@ class PartnersOpenInvoicesWebkit(report_sxw.rml_parse, CommonPartnersReportHeade
return res
HeaderFooterTextWebKitParser('report.account.account_report_open_invoices_webkit',
'account.account',
'addons/account_financial_report_webkit/report/templates/account_report_open_invoices.mako',
parser=PartnersOpenInvoicesWebkit)
HeaderFooterTextWebKitParser(
'report.account.account_report_open_invoices_webkit',
'account.account',
'addons/account_financial_report_webkit/report/templates/\
account_report_open_invoices.mako',
parser=PartnersOpenInvoicesWebkit)

43
account_financial_report_webkit/report/partner_balance.py
View File

@ -25,21 +25,28 @@ from datetime import datetime
from openerp import pooler
from openerp.report import report_sxw
from openerp.tools.translate import _
from .common_partner_balance_reports import CommonPartnerBalanceReportHeaderWebkit
from .common_partner_balance_reports \
import CommonPartnerBalanceReportHeaderWebkit
from .webkit_parser_header_fix import HeaderFooterTextWebKitParser
class PartnerBalanceWebkit(report_sxw.rml_parse, CommonPartnerBalanceReportHeaderWebkit):
class PartnerBalanceWebkit(report_sxw.rml_parse,
CommonPartnerBalanceReportHeaderWebkit):
def __init__(self, cursor, uid, name, context):
super(PartnerBalanceWebkit, self).__init__(cursor, uid, name, context=context)
super(PartnerBalanceWebkit, self).__init__(
cursor, uid, name, context=context)
self.pool = pooler.get_pool(self.cr.dbname)
self.cursor = self.cr
company = self.pool.get('res.users').browse(self.cr, uid, uid, context=context).company_id
header_report_name = ' - '.join((_('PARTNER BALANCE'), company.name, company.currency_id.name))
company = self.pool.get('res.users').browse(
self.cr, uid, uid, context=context).company_id
header_report_name = ' - '.join((_('PARTNER BALANCE'),
company.name,
company.currency_id.name))
footer_date_time = self.formatLang(str(datetime.today()), date_time=True)
footer_date_time = self.formatLang(
str(datetime.today()), date_time=True)
self.localcontext.update({
'cr': cursor,
@ -60,7 +67,8 @@ class PartnerBalanceWebkit(report_sxw.rml_parse, CommonPartnerBalanceReportHeade
('--header-left', header_report_name),
('--header-spacing', '2'),
('--footer-left', footer_date_time),
('--footer-right', ' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-right',
' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-line',),
],
})
@ -76,15 +84,18 @@ class PartnerBalanceWebkit(report_sxw.rml_parse, CommonPartnerBalanceReportHeade
return 'initial_balance'
def set_context(self, objects, data, ids, report_type=None):
"""Populate a ledger_lines attribute on each browse record that will be used
by mako template"""
objects, new_ids, context_report_values = self.compute_partner_balance_data(data)
"""Populate a ledger_lines attribute on each browse record that will
be used by mako template"""
objects, new_ids, context_report_values = self.\
compute_partner_balance_data(data)
self.localcontext.update(context_report_values)
return super(PartnerBalanceWebkit, self).set_context(objects, data, new_ids,
report_type=report_type)
return super(PartnerBalanceWebkit, self).set_context(
objects, data, new_ids, report_type=report_type)
HeaderFooterTextWebKitParser('report.account.account_report_partner_balance_webkit',
'account.account',
'addons/account_financial_report_webkit/report/templates/account_report_partner_balance.mako',
parser=PartnerBalanceWebkit)
HeaderFooterTextWebKitParser(
'report.account.account_report_partner_balance_webkit',
'account.account',
'addons/account_financial_report_webkit/report/templates/\
account_report_partner_balance.mako',
parser=PartnerBalanceWebkit)

104
account_financial_report_webkit/report/partners_ledger.py
View File

@ -30,17 +30,23 @@ from .common_partner_reports import CommonPartnersReportHeaderWebkit
from .webkit_parser_header_fix import HeaderFooterTextWebKitParser
class PartnersLedgerWebkit(report_sxw.rml_parse, CommonPartnersReportHeaderWebkit):
class PartnersLedgerWebkit(report_sxw.rml_parse,
CommonPartnersReportHeaderWebkit):
def __init__(self, cursor, uid, name, context):
super(PartnersLedgerWebkit, self).__init__(cursor, uid, name, context=context)
super(PartnersLedgerWebkit, self).__init__(
cursor, uid, name, context=context)
self.pool = pooler.get_pool(self.cr.dbname)
self.cursor = self.cr
company = self.pool.get('res.users').browse(self.cr, uid, uid, context=context).company_id
header_report_name = ' - '.join((_('PARTNER LEDGER'), company.name, company.currency_id.name))
company = self.pool.get('res.users').browse(
self.cr, uid, uid, context=context).company_id
header_report_name = ' - '.join((_('PARTNER LEDGER'),
company.name,
company.currency_id.name))
footer_date_time = self.formatLang(str(datetime.today()), date_time=True)
footer_date_time = self.formatLang(
str(datetime.today()), date_time=True)
self.localcontext.update({
'cr': cursor,
@ -61,7 +67,8 @@ class PartnersLedgerWebkit(report_sxw.rml_parse, CommonPartnersReportHeaderWebki
('--header-left', header_report_name),
('--header-spacing', '2'),
('--footer-left', footer_date_time),
('--footer-right', ' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-right',
' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-line',),
],
})
@ -77,8 +84,8 @@ class PartnersLedgerWebkit(report_sxw.rml_parse, CommonPartnersReportHeaderWebki
return 'initial_balance'
def set_context(self, objects, data, ids, report_type=None):
"""Populate a ledger_lines attribute on each browse record that will be used
by mako template"""
"""Populate a ledger_lines attribute on each browse record that will
be used by mako template"""
new_ids = data['form']['chart_account_id']
# account partner memoizer
@ -118,45 +125,50 @@ class PartnersLedgerWebkit(report_sxw.rml_parse, CommonPartnersReportHeaderWebki
start = start_period
stop = stop_period
# when the opening period is included in the selected range of periods and
# the opening period contains move lines, we must not compute the initial balance from previous periods
# but only display the move lines of the opening period
# we identify them as:
# - 'initial_balance' means compute the sums of move lines from previous periods
# - 'opening_balance' means display the move lines of the opening period
# when the opening period is included in the selected range of periods
# and the opening period contains move lines, we must not compute the
# initial balance from previous periods but only display the move lines
# of the opening period we identify them as:
# - 'initial_balance' means compute the sums of move lines from
# previous periods
# - 'opening_balance' means display the move lines of the opening
# period
init_balance = main_filter in ('filter_no', 'filter_period')
initial_balance_mode = init_balance and self._get_initial_balance_mode(start) or False
initial_balance_mode = init_balance and self._get_initial_balance_mode(
start) or False
initial_balance_lines = {}
if initial_balance_mode == 'initial_balance':
initial_balance_lines = self._compute_partners_initial_balances(accounts,
start_period,
partner_filter=partner_ids,
exclude_reconcile=False)
initial_balance_lines = self._compute_partners_initial_balances(
accounts, start_period, partner_filter=partner_ids,
exclude_reconcile=False)
ledger_lines = self._compute_partner_ledger_lines(accounts,
main_filter,
target_move,
start,
stop,
partner_filter=partner_ids)
ledger_lines = self._compute_partner_ledger_lines(
accounts, main_filter, target_move, start, stop,
partner_filter=partner_ids)
objects = []
for account in self.pool.get('account.account').browse(self.cursor, self.uid, accounts):
for account in self.pool.get('account.account').browse(self.cursor,
self.uid,
accounts):
account.ledger_lines = ledger_lines.get(account.id, {})
account.init_balance = initial_balance_lines.get(account.id, {})
## we have to compute partner order based on inital balance
## and ledger line as we may have partner with init bal
## that are not in ledger line and vice versa
# we have to compute partner order based on inital balance
# and ledger line as we may have partner with init bal
# that are not in ledger line and vice versa
ledg_lines_pids = ledger_lines.get(account.id, {}).keys()
if initial_balance_mode:
non_null_init_balances = dict([(ib, amounts) for ib, amounts in account.init_balance.iteritems()
if amounts['init_balance'] or amounts['init_balance_currency']])
non_null_init_balances = dict(
[(ib, amounts) for ib, amounts
in account.init_balance.iteritems()
if amounts['init_balance']
or amounts['init_balance_currency']])
init_bal_lines_pids = non_null_init_balances.keys()
else:
account.init_balance = {}
init_bal_lines_pids = []
account.partners_order = self._order_partners(ledg_lines_pids, init_bal_lines_pids)
account.partners_order = self._order_partners(
ledg_lines_pids, init_bal_lines_pids)
objects.append(account)
self.localcontext.update({
@ -170,20 +182,18 @@ class PartnersLedgerWebkit(report_sxw.rml_parse, CommonPartnersReportHeaderWebki
'initial_balance_mode': initial_balance_mode,
})
return super(PartnersLedgerWebkit, self).set_context(objects, data, new_ids,
report_type=report_type)
return super(PartnersLedgerWebkit, self).set_context(
objects, data, new_ids, report_type=report_type)
def _compute_partner_ledger_lines(self, accounts_ids, main_filter, target_move, start, stop, partner_filter=False):
def _compute_partner_ledger_lines(self, accounts_ids, main_filter,
target_move, start, stop,
partner_filter=False):
res = defaultdict(dict)
for acc_id in accounts_ids:
move_line_ids = self.get_partners_move_lines_ids(acc_id,
main_filter,
start,
stop,
target_move,
exclude_reconcile=False,
partner_filter=partner_filter)
move_line_ids = self.get_partners_move_lines_ids(
acc_id, main_filter, start, stop, target_move,
exclude_reconcile=False, partner_filter=partner_filter)
if not move_line_ids:
continue
for partner_id in move_line_ids:
@ -193,7 +203,9 @@ class PartnersLedgerWebkit(report_sxw.rml_parse, CommonPartnersReportHeaderWebki
return res
HeaderFooterTextWebKitParser('report.account.account_report_partners_ledger_webkit',
'account.account',
'addons/account_financial_report_webkit/report/templates/account_report_partners_ledger.mako',
parser=PartnersLedgerWebkit)
HeaderFooterTextWebKitParser(
'report.account.account_report_partners_ledger_webkit',
'account.account',
'addons/account_financial_report_webkit/report/templates/\
account_report_partners_ledger.mako',
parser=PartnersLedgerWebkit)

68
account_financial_report_webkit/report/print_journal.py
View File

@ -1,19 +1,20 @@
# -*- coding: utf-8 -*-
##############################################################################
#
# account_financial_report_webkit module for OpenERP, Webkit based extended report financial report
# account_financial_report_webkit module for OpenERP, Webkit based
# extended report financial report
# Copyright (C) 2012 SYLEAM Info Services (<http://www.syleam.fr/>)
# Sebastien LANGE <sebastien.lange@syleam.fr>
#
# This file is a part of account_financial_report_webkit
#
# account_financial_report_webkit is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# account_financial_report_webkit is free software: you can redistribute it
# and/or modify it under the terms of the GNU Affero General Public License
# as published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# account_financial_report_webkit is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# account_financial_report_webkit is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
@ -34,17 +35,22 @@ from webkit_parser_header_fix import HeaderFooterTextWebKitParser
class PrintJournalWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
def __init__(self, cursor, uid, name, context):
super(PrintJournalWebkit, self).__init__(cursor, uid, name, context=context)
super(PrintJournalWebkit, self).__init__(cursor, uid, name,
context=context)
self.pool = pooler.get_pool(self.cr.dbname)
self.cursor = self.cr
company_obj = self.pool.get('res.company')
company_id = company_obj._company_default_get(self.cr, uid, 'res.users', context=context)
company_id = company_obj._company_default_get(self.cr, uid,
'res.users',
context=context)
company = company_obj.browse(self.cr, uid, company_id, context=context)
header_report_name = ' - '.join((_('JOURNALS'), company.name, company.currency_id.name))
header_report_name = ' - '.join((_('JOURNALS'), company.name,
company.currency_id.name))
footer_date_time = self.formatLang(str(datetime.today()), date_time=True)
footer_date_time = self.formatLang(str(datetime.today()),
date_time=True)
self.localcontext.update({
'cr': cursor,
@ -66,14 +72,15 @@ class PrintJournalWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
('--header-left', header_report_name),
('--header-spacing', '2'),
('--footer-left', footer_date_time),
('--footer-right', ' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-right', ' '.join((_('Page'), '[page]', _('of'),
'[topage]'))),
('--footer-line',),
],
})
def set_context(self, objects, data, ids, report_type=None):
"""Populate a ledger_lines attribute on each browse record that will be used
by mako template"""
"""Populate a ledger_lines attribute on each browse record that will
be used by mako template"""
# Reading form
main_filter = self._get_form_param('filter', data, default='filter_no')
@ -90,8 +97,10 @@ class PrintJournalWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
domain = [('journal_id', 'in', journal_ids)]
if main_filter == 'filter_no':
domain += [
('date', '>=', self.get_first_fiscalyear_period(fiscalyear).date_start),
('date', '<=', self.get_last_fiscalyear_period(fiscalyear).date_stop),
('date', '>=',
self.get_first_fiscalyear_period(fiscalyear).date_start),
('date', '<=',
self.get_last_fiscalyear_period(fiscalyear).date_stop),
]
# computation of move lines
elif main_filter == 'filter_date':
@ -100,7 +109,10 @@ class PrintJournalWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
('date', '<=', stop_date),
]
elif main_filter == 'filter_period':
period_ids = account_period_obj.build_ctx_periods(self.cursor, self.uid, start_period.id, stop_period.id)
period_ids = account_period_obj.build_ctx_periods(self.cursor,
self.uid,
start_period.id,
stop_period.id)
domain = [
('period_id', 'in', period_ids),
]
@ -111,7 +123,8 @@ class PrintJournalWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
('journal_id', 'in', journal_ids),
('period_id', 'in', period_ids),
])
objects = account_journal_period_obj.browse(self.cursor, self.uid, new_ids)
objects = account_journal_period_obj.browse(self.cursor, self.uid,
new_ids)
# Sort by journal and period
objects.sort(key=lambda a: (a.journal_id.code, a.period_id.date_start))
move_obj = self.pool.get('account.move')
@ -122,8 +135,10 @@ class PrintJournalWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
]
if target_move == 'posted':
domain_arg += [('state', '=', 'posted')]
move_ids = move_obj.search(self.cursor, self.uid, domain_arg, order="name")
journal_period.moves = move_obj.browse(self.cursor, self.uid, move_ids)
move_ids = move_obj.search(self.cursor, self.uid, domain_arg,
order="name")
journal_period.moves = move_obj.browse(self.cursor, self.uid,
move_ids)
# Sort account move line by account accountant
for move in journal_period.moves:
move.line_id.sort(key=lambda a: (a.date, a.account_id.code))
@ -137,11 +152,14 @@ class PrintJournalWebkit(report_sxw.rml_parse, CommonReportHeaderWebkit):
'chart_account': chart_account,
})
return super(PrintJournalWebkit, self).set_context(objects, data, new_ids, report_type=report_type)
return super(PrintJournalWebkit, self).set_context(
objects, data, new_ids, report_type=report_type)
HeaderFooterTextWebKitParser('report.account.account_report_print_journal_webkit',
'account.journal.period',
'addons/account_financial_report_webkit/report/templates/account_report_print_journal.mako',
parser=PrintJournalWebkit)
HeaderFooterTextWebKitParser(
'report.account.account_report_print_journal_webkit',
'account.journal.period',
'addons/account_financial_report_webkit/report/templates/\
account_report_print_journal.mako',
parser=PrintJournalWebkit)
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

39
account_financial_report_webkit/report/trial_balance.py
View File

@ -33,17 +33,22 @@ def sign(number):
return cmp(number, 0)
class TrialBalanceWebkit(report_sxw.rml_parse, CommonBalanceReportHeaderWebkit):
class TrialBalanceWebkit(report_sxw.rml_parse,
CommonBalanceReportHeaderWebkit):
def __init__(self, cursor, uid, name, context):
super(TrialBalanceWebkit, self).__init__(cursor, uid, name, context=context)
super(TrialBalanceWebkit, self).__init__(cursor, uid, name,
context=context)
self.pool = pooler.get_pool(self.cr.dbname)
self.cursor = self.cr
company = self.pool.get('res.users').browse(self.cr, uid, uid, context=context).company_id
header_report_name = ' - '.join((_('TRIAL BALANCE'), company.name, company.currency_id.name))
company = self.pool.get('res.users').browse(self.cr, uid, uid,
context=context).company_id
header_report_name = ' - '.join((_('TRIAL BALANCE'), company.name,
company.currency_id.name))
footer_date_time = self.formatLang(str(datetime.today()), date_time=True)
footer_date_time = self.formatLang(str(datetime.today()),
date_time=True)
self.localcontext.update({
'cr': cursor,
@ -63,22 +68,26 @@ class TrialBalanceWebkit(report_sxw.rml_parse, CommonBalanceReportHeaderWebkit):
('--header-left', header_report_name),
('--header-spacing', '2'),
('--footer-left', footer_date_time),
('--footer-right', ' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
('--footer-right', ' '.join((_('Page'), '[page]', _('of'),
'[topage]'))),
('--footer-line',),
],
})
def set_context(self, objects, data, ids, report_type=None):
"""Populate a ledger_lines attribute on each browse record that will be used
by mako template"""
objects, new_ids, context_report_values = self.compute_balance_data(data)
"""Populate a ledger_lines attribute on each browse record that will
be used by mako template"""
objects, new_ids, context_report_values = self.\
compute_balance_data(data)
self.localcontext.update(context_report_values)
return super(TrialBalanceWebkit, self).set_context(objects, data, new_ids,
report_type=report_type)
return super(TrialBalanceWebkit, self).set_context(
objects, data, new_ids, report_type=report_type)
HeaderFooterTextWebKitParser('report.account.account_report_trial_balance_webkit',
'account.account',
'addons/account_financial_report_webkit/report/templates/account_report_trial_balance.mako',
parser=TrialBalanceWebkit)
HeaderFooterTextWebKitParser(
'report.account.account_report_trial_balance_webkit',
'account.account',
'addons/account_financial_report_webkit/report/templates/\
account_report_trial_balance.mako',
parser=TrialBalanceWebkit)

62
account_financial_report_webkit/report/webkit_parser_header_fix.py
View File

@ -56,7 +56,8 @@ _logger = logging.getLogger('financial.reports.webkit')
# them in the localcontext with a key 'additional_args'
# for instance:
# header_report_name = _('PARTNER LEDGER')
# footer_date_time = self.formatLang(str(datetime.today()), date_time=True)
# footer_date_time = self.formatLang(str(datetime.today()),
# date_time=True)
# self.localcontext.update({
# 'additional_args': [
# ('--header-font-name', 'Helvetica'),
@ -65,7 +66,8 @@ _logger = logging.getLogger('financial.reports.webkit')
# ('--footer-font-size', '7'),
# ('--header-left', header_report_name),
# ('--footer-left', footer_date_time),
# ('--footer-right', ' '.join((_('Page'), '[page]', _('of'), '[topage]'))),
# ('--footer-right', ' '.join((_('Page'), '[page]', _('of'),
# '[topage]'))),
# ('--footer-line',),
# ],
# })
@ -82,8 +84,10 @@ def mako_template(text):
This template uses UTF-8 encoding
"""
tmp_lookup = TemplateLookup() # we need it in order to allow inclusion and inheritance
return Template(text, input_encoding='utf-8', output_encoding='utf-8', lookup=tmp_lookup)
tmp_lookup = TemplateLookup(
) # we need it in order to allow inclusion and inheritance
return Template(text, input_encoding='utf-8', output_encoding='utf-8',
lookup=tmp_lookup)
class HeaderFooterTextWebKitParser(webkit_report.WebKitParser):
@ -106,17 +110,29 @@ class HeaderFooterTextWebKitParser(webkit_report.WebKitParser):
command.extend(['--encoding', 'utf-8'])
if webkit_header.margin_top:
command.extend(['--margin-top', str(webkit_header.margin_top).replace(',', '.')])
command.extend(
['--margin-top',
str(webkit_header.margin_top).replace(',', '.')])
if webkit_header.margin_bottom:
command.extend(['--margin-bottom', str(webkit_header.margin_bottom).replace(',', '.')])
command.extend(
['--margin-bottom',
str(webkit_header.margin_bottom).replace(',', '.')])
if webkit_header.margin_left:
command.extend(['--margin-left', str(webkit_header.margin_left).replace(',', '.')])
command.extend(
['--margin-left',
str(webkit_header.margin_left).replace(',', '.')])
if webkit_header.margin_right:
command.extend(['--margin-right', str(webkit_header.margin_right).replace(',', '.')])
command.extend(
['--margin-right',
str(webkit_header.margin_right).replace(',', '.')])
if webkit_header.orientation:
command.extend(['--orientation', str(webkit_header.orientation).replace(',', '.')])
command.extend(
['--orientation',
str(webkit_header.orientation).replace(',', '.')])
if webkit_header.format:
command.extend(['--page-size', str(webkit_header.format).replace(',', '.')])
command.extend(
['--page-size',
str(webkit_header.format).replace(',', '.')])
if parser_instance.localcontext.get('additional_args', False):
for arg in parser_instance.localcontext['additional_args']:
@ -143,10 +159,14 @@ class HeaderFooterTextWebKitParser(webkit_report.WebKitParser):
if not error_message:
error_message = _('No diagnosis message was provided')
else:
error_message = _('The following diagnosis message was provided:\n') + error_message
error_message = _(
'The following diagnosis message was provided:\n') + \
error_message
if status:
raise except_osv(_('Webkit error'),
_("The command 'wkhtmltopdf' failed with error code = %s. Message: %s") % (status, error_message))
_("The command 'wkhtmltopdf' failed with \
error code = %s. Message: %s") %
(status, error_message))
with open(out_filename, 'rb') as pdf_file:
pdf = pdf_file.read()
os.close(fd)
@ -161,7 +181,8 @@ class HeaderFooterTextWebKitParser(webkit_report.WebKitParser):
return pdf
# override needed to keep the attachments' storing procedure
def create_single_pdf(self, cursor, uid, ids, data, report_xml, context=None):
def create_single_pdf(self, cursor, uid, ids, data, report_xml,
context=None):
"""generate the PDF"""
if context is None:
@ -184,27 +205,30 @@ class HeaderFooterTextWebKitParser(webkit_report.WebKitParser):
template = False
if report_xml.report_file:
path = addons.get_module_resource(*report_xml.report_file.split(os.path.sep))
path = addons.get_module_resource(
*report_xml.report_file.split(os.path.sep))
if os.path.exists(path):
template = file(path).read()
if not template and report_xml.report_webkit_data:
template = report_xml.report_webkit_data
if not template:
raise except_osv(_('Error!'), _('Webkit Report template not found !'))
raise except_osv(
_('Error!'), _('Webkit Report template not found !'))
header = report_xml.webkit_header.html
if not header and report_xml.header:
raise except_osv(
_('No header defined for this Webkit report!'),
_('Please set a header in company settings.')
)
_('No header defined for this Webkit report!'),
_('Please set a header in company settings.')
)
css = report_xml.webkit_header.css
if not css:
css = ''
translate_call = partial(self.translate_call, parser_instance)
#default_filters=['unicode', 'entity'] can be used to set global filter
# default_filters=['unicode', 'entity'] can be used to set global
# filter
body_mako_tpl = mako_template(template)
helper = WebKitHelper(cursor, uid, report_xml.id, context)
if report_xml.precise_mode:

191
account_financial_report_webkit/wizard/balance_common.py
View File

@ -47,6 +47,7 @@ def previous_year_date(date, nb_prev=1):
class AccountBalanceCommonWizard(orm.TransientModel):
"""Will launch trial balance report and pass required args"""
_inherit = "account.common.account.report"
@ -66,53 +67,68 @@ class AccountBalanceCommonWizard(orm.TransientModel):
M2O_DYNAMIC_FIELDS = [f % index for f in ["comp%s_fiscalyear_id",
"comp%s_period_from",
"comp%s_period_to"]
for index in range(COMPARISON_LEVEL)]
for index in range(COMPARISON_LEVEL)]
SIMPLE_DYNAMIC_FIELDS = [f % index for f in ["comp%s_filter",
"comp%s_date_from",
"comp%s_date_to"]
for index in range(COMPARISON_LEVEL)]
for index in range(COMPARISON_LEVEL)]
DYNAMIC_FIELDS = M2O_DYNAMIC_FIELDS + SIMPLE_DYNAMIC_FIELDS
def _get_account_ids(self, cr, uid, context=None):
res = False
if context.get('active_model', False) == 'account.account' and context.get('active_ids', False):
if context.get('active_model', False) == 'account.account' \
and context.get('active_ids', False):
res = context['active_ids']
return res
_columns = {
'account_ids': fields.many2many('account.account', string='Filter on accounts',
help="Only selected accounts will be printed. Leave empty to print all accounts."),
'filter': fields.selection([('filter_no', 'No Filters'),
('filter_date', 'Date'),
('filter_period', 'Periods'),
('filter_opening', 'Opening Only')],
"Filter by",
required=True,
help='Filter by date: no opening balance will be displayed. '
'(opening balance can only be computed based on period to be correct).'),
'account_ids': fields.many2many(
'account.account', string='Filter on accounts',
help="Only selected accounts will be printed. Leave empty to \
print all accounts."),
'filter': fields.selection(
[('filter_no', 'No Filters'),
('filter_date', 'Date'),
('filter_period', 'Periods'),
('filter_opening', 'Opening Only')],
"Filter by",
required=True,
help='Filter by date: no opening balance will be displayed. '
'(opening balance can only be computed based on period to be \
correct).'),
}
for index in range(COMPARISON_LEVEL):
_columns.update(
{"comp%s_filter" % index: fields.selection(COMPARE_SELECTION, string='Compare By', required=True),
"comp%s_fiscalyear_id" % index: fields.many2one('account.fiscalyear', 'Fiscal Year'),
"comp%s_period_from" % index: fields.many2one('account.period', 'Start Period'),
"comp%s_period_to" % index: fields.many2one('account.period', 'End Period'),
"comp%s_date_from" % index: fields.date("Start Date"),
"comp%s_date_to" % index: fields.date("End Date")})
{"comp%s_filter" % index:
fields.selection(
COMPARE_SELECTION, string='Compare By', required=True),
"comp%s_fiscalyear_id" % index:
fields.many2one('account.fiscalyear', 'Fiscal Year'),
"comp%s_period_from" % index:
fields.many2one('account.period', 'Start Period'),
"comp%s_period_to" % index:
fields.many2one('account.period', 'End Period'),
"comp%s_date_from" % index:
fields.date("Start Date"),
"comp%s_date_to" % index:
fields.date("End Date")})
_defaults = {
'account_ids': _get_account_ids,
}
def _check_fiscalyear(self, cr, uid, ids, context=None):
obj = self.read(cr, uid, ids[0], ['fiscalyear_id', 'filter'], context=context)
obj = self.read(
cr, uid, ids[0], ['fiscalyear_id', 'filter'], context=context)
if not obj['fiscalyear_id'] and obj['filter'] == 'filter_no':
return False
return True
_constraints = [
(_check_fiscalyear, 'When no Fiscal year is selected, you must choose to filter by periods or by date.', ['filter']),
(_check_fiscalyear,
'When no Fiscal year is selected, you must choose to filter by \
periods or by date.', ['filter']),
]
def default_get(self, cr, uid, fields, context=None):
@ -128,15 +144,19 @@ class AccountBalanceCommonWizard(orm.TransientModel):
@return: A dictionary which of fields with values.
"""
res = super(AccountBalanceCommonWizard, self).default_get(cr, uid, fields, context=context)
res = super(AccountBalanceCommonWizard, self).default_get(
cr, uid, fields, context=context)
for index in range(self.COMPARISON_LEVEL):
field = "comp%s_filter" % (index,)
if not res.get(field, False):
res[field] = 'filter_no'
return res
def fields_view_get(self, cr, uid, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
res = super(AccountBalanceCommonWizard, self).fields_view_get(cr, uid, view_id, view_type, context=context, toolbar=toolbar, submenu=submenu)
def fields_view_get(self, cr, uid, view_id=None, view_type='form',
context=None, toolbar=False, submenu=False):
res = super(AccountBalanceCommonWizard, self).fields_view_get(
cr, uid, view_id, view_type, context=context, toolbar=toolbar,
submenu=submenu)
res['fields'].update(self.fields_get(cr, uid,
allfields=self.DYNAMIC_FIELDS,
@ -161,16 +181,23 @@ class AccountBalanceCommonWizard(orm.TransientModel):
modifiers_and_append(etree.Element(
'field',
{'name': "comp%s_filter" % index,
'on_change': "onchange_comp_filter(%(index)s, filter, comp%(index)s_filter, fiscalyear_id, date_from, date_to)" % {'index': index}}))
'on_change': "onchange_comp_filter(%(index)s, filter,\
comp%(index)s_filter, fiscalyear_id, date_from, date_to)"
% {'index': index}}))
modifiers_and_append(etree.Element(
'field',
{'name': "comp%s_fiscalyear_id" % index,
'attrs':
"{'required': [('comp%(index)s_filter','in',('filter_year','filter_opening'))]," \
" 'invisible': [('comp%(index)s_filter','not in',('filter_year','filter_opening'))]}" % {'index': index}}))
"{'required': [('comp%(index)s_filter','in',\
('filter_year','filter_opening'))],"
" 'invisible': [('comp%(index)s_filter','not in',\
('filter_year','filter_opening'))]}" % {'index': index}}))
dates_attrs = "{'required': [('comp%(index)s_filter','=','filter_date')], " \
" 'invisible': [('comp%(index)s_filter','!=','filter_date')]}" % {'index': index}
dates_attrs = "{'required': [('comp%(index)s_filter','=',\
'filter_date')], " \
" 'invisible': [('comp%(index)s_filter','!=',\
'filter_date')]}" % {
'index': index}
modifiers_and_append(etree.Element(
'separator',
{'string': _('Dates'),
@ -185,8 +212,11 @@ class AccountBalanceCommonWizard(orm.TransientModel):
{'name': "comp%s_date_to" % index,
'attrs': dates_attrs}))
periods_attrs = "{'required': [('comp%(index)s_filter','=','filter_period')]," \
" 'invisible': [('comp%(index)s_filter','!=','filter_period')]}" % {'index': index}
periods_attrs = "{'required': [('comp%(index)s_filter','=',\
'filter_period')]," \
" 'invisible': [('comp%(index)s_filter','!=',\
'filter_period')]}" % {
'index': index}
periods_domain = "[('special', '=', False)]"
modifiers_and_append(etree.Element(
'separator',
@ -209,24 +239,34 @@ class AccountBalanceCommonWizard(orm.TransientModel):
res['arch'] = etree.tostring(eview)
return res
def onchange_filter(self, cr, uid, ids, filter='filter_no', fiscalyear_id=False, context=None):
def onchange_filter(self, cr, uid, ids, filter='filter_no',
fiscalyear_id=False, context=None):
res = {}
if filter == 'filter_no':
res['value'] = {'period_from': False, 'period_to': False, 'date_from': False, 'date_to': False}
res['value'] = {'period_from': False,
'period_to': False,
'date_from': False,
'date_to': False}
if filter == 'filter_date':
if fiscalyear_id:
fyear = self.pool.get('account.fiscalyear').browse(cr, uid, fiscalyear_id, context=context)
fyear = self.pool.get('account.fiscalyear').browse(
cr, uid, fiscalyear_id, context=context)
date_from = fyear.date_start
date_to = fyear.date_stop > time.strftime('%Y-%m-%d') and time.strftime('%Y-%m-%d') or fyear.date_stop
date_to = fyear.date_stop > time.strftime(
'%Y-%m-%d') and time.strftime('%Y-%m-%d') \
or fyear.date_stop
else:
date_from, date_to = time.strftime('%Y-01-01'), time.strftime('%Y-%m-%d')
res['value'] = {'period_from': False, 'period_to': False, 'date_from': date_from, 'date_to': date_to}
date_from, date_to = time.strftime(
'%Y-01-01'), time.strftime('%Y-%m-%d')
res['value'] = {'period_from': False, 'period_to':
False, 'date_from': date_from, 'date_to': date_to}
if filter == 'filter_period' and fiscalyear_id:
start_period = end_period = False
cr.execute('''
SELECT * FROM (SELECT p.id
FROM account_period p
LEFT JOIN account_fiscalyear f ON (p.fiscalyear_id = f.id)
LEFT JOIN account_fiscalyear f
ON (p.fiscalyear_id = f.id)
WHERE f.id = %s
AND COALESCE(p.special, FALSE) = FALSE
ORDER BY p.date_start ASC
@ -234,31 +274,41 @@ class AccountBalanceCommonWizard(orm.TransientModel):
UNION ALL
SELECT * FROM (SELECT p.id
FROM account_period p
LEFT JOIN account_fiscalyear f ON (p.fiscalyear_id = f.id)
LEFT JOIN account_fiscalyear f
ON (p.fiscalyear_id = f.id)
WHERE f.id = %s
AND p.date_start < NOW()
AND COALESCE(p.special, FALSE) = FALSE
ORDER BY p.date_stop DESC
LIMIT 1) AS period_stop''', (fiscalyear_id, fiscalyear_id))
LIMIT 1) AS period_stop''',
(fiscalyear_id, fiscalyear_id))
periods = [i[0] for i in cr.fetchall()]
if periods:
start_period = end_period = periods[0]
if len(periods) > 1:
end_period = periods[1]
res['value'] = {'period_from': start_period, 'period_to': end_period, 'date_from': False, 'date_to': False}
res['value'] = {'period_from': start_period, 'period_to':
end_period, 'date_from': False, 'date_to': False}
return res
def onchange_comp_filter(self, cr, uid, ids, index, main_filter='filter_no', comp_filter='filter_no', fiscalyear_id=False, start_date=False, stop_date=False, context=None):
def onchange_comp_filter(self, cr, uid, ids, index,
main_filter='filter_no', comp_filter='filter_no',
fiscalyear_id=False, start_date=False,
stop_date=False, context=None):
res = {}
fy_obj = self.pool.get('account.fiscalyear')
last_fiscalyear_id = False
if fiscalyear_id:
fiscalyear = fy_obj.browse(cr, uid, fiscalyear_id, context=context)
last_fiscalyear_ids = fy_obj.search(cr, uid, [('date_stop', '<', fiscalyear.date_start)],
limit=self.COMPARISON_LEVEL, order='date_start desc', context=context)
last_fiscalyear_ids = fy_obj.search(
cr, uid, [('date_stop', '<', fiscalyear.date_start)],
limit=self.COMPARISON_LEVEL, order='date_start desc',
context=context)
if last_fiscalyear_ids:
if len(last_fiscalyear_ids) > index:
last_fiscalyear_id = last_fiscalyear_ids[index] # first element for the comparison 1, second element for the comparison 2
# first element for the comparison 1, second element for
# the comparison 2
last_fiscalyear_id = last_fiscalyear_ids[index]
fy_id_field = "comp%s_fiscalyear_id" % (index,)
period_from_field = "comp%s_period_from" % (index,)
@ -268,37 +318,46 @@ class AccountBalanceCommonWizard(orm.TransientModel):
if comp_filter == 'filter_no':
res['value'] = {
fy_id_field: False,
period_from_field: False,
period_to_field: False,
date_from_field: False,
date_to_field: False
}
fy_id_field: False,
period_from_field: False,
period_to_field: False,
date_from_field: False,
date_to_field: False
}
if comp_filter in ('filter_year', 'filter_opening'):
res['value'] = {
fy_id_field: last_fiscalyear_id,
period_from_field: False,
period_to_field: False,
date_from_field: False,
date_to_field: False
}
fy_id_field: last_fiscalyear_id,
period_from_field: False,
period_to_field: False,
date_from_field: False,
date_to_field: False
}
if comp_filter == 'filter_date':
dates = {}
if main_filter == 'filter_date':
dates = {
'date_start': previous_year_date(start_date, index + 1).strftime('%Y-%m-%d'),
'date_stop': previous_year_date(stop_date, index + 1).strftime('%Y-%m-%d'),
}
'date_start': previous_year_date(start_date, index + 1).
strftime('%Y-%m-%d'),
'date_stop': previous_year_date(stop_date, index + 1).
strftime('%Y-%m-%d'),
}
elif last_fiscalyear_id:
dates = fy_obj.read(cr, uid, last_fiscalyear_id, ['date_start', 'date_stop'], context=context)
dates = fy_obj.read(
cr, uid, last_fiscalyear_id, ['date_start', 'date_stop'],
context=context)
res['value'] = {fy_id_field: False, period_from_field: False, period_to_field: False, date_from_field: dates.get('date_start', False), date_to_field: dates.get('date_stop', False)}
res['value'] = {fy_id_field: False,
period_from_field: False,
period_to_field: False,
date_from_field: dates.get('date_start', False),
date_to_field: dates.get('date_stop', False)}
if comp_filter == 'filter_period' and last_fiscalyear_id:
start_period = end_period = False
cr.execute('''
SELECT * FROM (SELECT p.id
FROM account_period p
LEFT JOIN account_fiscalyear f ON (p.fiscalyear_id = f.id)
LEFT JOIN account_fiscalyear f
ON (p.fiscalyear_id = f.id)
WHERE f.id = %(fiscalyear)s
AND COALESCE(p.special, FALSE) = FALSE
ORDER BY p.date_start ASC
@ -306,12 +365,14 @@ class AccountBalanceCommonWizard(orm.TransientModel):
UNION ALL
SELECT * FROM (SELECT p.id
FROM account_period p
LEFT JOIN account_fiscalyear f ON (p.fiscalyear_id = f.id)
LEFT JOIN account_fiscalyear f
ON (p.fiscalyear_id = f.id)
WHERE f.id = %(fiscalyear)s
AND p.date_start < NOW()
AND COALESCE(p.special, FALSE) = FALSE
ORDER BY p.date_stop DESC
LIMIT 1) AS period_stop''', {'fiscalyear': last_fiscalyear_id})
LIMIT 1) AS period_stop''',
{'fiscalyear': last_fiscalyear_id})
periods = [i[0] for i in cr.fetchall()]
if periods and len(periods) > 1:
start_period = end_period = periods[0]

78
account_financial_report_webkit/wizard/general_ledger_wizard.py
View File

@ -25,6 +25,7 @@ from openerp.osv import fields, orm
class AccountReportGeneralLedgerWizard(orm.TransientModel):
"""Will launch general ledger report and pass required args"""
_inherit = "account.common.account.report"
@ -33,7 +34,8 @@ class AccountReportGeneralLedgerWizard(orm.TransientModel):
def _get_account_ids(self, cr, uid, context=None):
res = False
if context.get('active_model', False) == 'account.account' and context.get('active_ids', False):
if context.get('active_model', False) == 'account.account' \
and context.get('active_ids', False):
res = context['active_ids']
return res
@ -41,13 +43,18 @@ class AccountReportGeneralLedgerWizard(orm.TransientModel):
'amount_currency': fields.boolean("With Currency",
help="It adds the currency column"),
'display_account': fields.selection([('bal_all', 'All'),
('bal_mix', 'With transactions or non zero balance')],
'Display accounts',
required=True),
'account_ids': fields.many2many('account.account', string='Filter on accounts',
help="""Only selected accounts will be printed. Leave empty to print all accounts."""),
'centralize': fields.boolean('Activate Centralization', help='Uncheck to display all the details of centralized accounts.')
'display_account': fields.selection(
[('bal_all', 'All'),
('bal_mix', 'With transactions or non zero balance')],
'Display accounts',
required=True),
'account_ids': fields.many2many(
'account.account', string='Filter on accounts',
help="""Only selected accounts will be printed. Leave empty to
print all accounts."""),
'centralize': fields.boolean(
'Activate Centralization',
help='Uncheck to display all the details of centralized accounts.')
}
_defaults = {
'amount_currency': False,
@ -57,17 +64,21 @@ class AccountReportGeneralLedgerWizard(orm.TransientModel):
}
def _check_fiscalyear(self, cr, uid, ids, context=None):
obj = self.read(cr, uid, ids[0], ['fiscalyear_id', 'filter'], context=context)
obj = self.read(
cr, uid, ids[0], ['fiscalyear_id', 'filter'], context=context)
if not obj['fiscalyear_id'] and obj['filter'] == 'filter_no':
return False
return True
_constraints = [
(_check_fiscalyear, 'When no Fiscal year is selected, you must choose to filter by periods or by date.', ['filter']),
(_check_fiscalyear,
'When no Fiscal year is selected, you must choose to filter by \
periods or by date.', ['filter']),
]
def pre_print_report(self, cr, uid, ids, data, context=None):
data = super(AccountReportGeneralLedgerWizard, self).pre_print_report(cr, uid, ids, data, context)
data = super(AccountReportGeneralLedgerWizard, self).pre_print_report(
cr, uid, ids, data, context)
# will be used to attach the report on the main account
data['ids'] = [data['form']['chart_account_id']]
vals = self.read(cr, uid, ids,
@ -79,34 +90,40 @@ class AccountReportGeneralLedgerWizard(orm.TransientModel):
data['form'].update(vals)
return data
def onchange_filter(self, cr, uid, ids, filter='filter_no', fiscalyear_id=False, context=None):
def onchange_filter(self, cr, uid, ids, filter='filter_no',
fiscalyear_id=False, context=None):
res = {}
if filter == 'filter_no':
res['value'] = {
'period_from': False,
'period_to': False,
'date_from': False,
'date_to': False,
}
'period_from': False,
'period_to': False,
'date_from': False,
'date_to': False,
}
if filter == 'filter_date':
if fiscalyear_id:
fyear = self.pool.get('account.fiscalyear').browse(cr, uid, fiscalyear_id, context=context)
fyear = self.pool.get('account.fiscalyear').browse(
cr, uid, fiscalyear_id, context=context)
date_from = fyear.date_start
date_to = fyear.date_stop > time.strftime('%Y-%m-%d') and time.strftime('%Y-%m-%d') or fyear.date_stop
date_to = fyear.date_stop > time.strftime(
'%Y-%m-%d') and time.strftime('%Y-%m-%d') \
or fyear.date_stop
else:
date_from, date_to = time.strftime('%Y-01-01'), time.strftime('%Y-%m-%d')
date_from, date_to = time.strftime(
'%Y-01-01'), time.strftime('%Y-%m-%d')
res['value'] = {
'period_from': False,
'period_to': False,
'date_from': date_from,
'date_to': date_to
}
'period_from': False,
'period_to': False,
'date_from': date_from,
'date_to': date_to
}
if filter == 'filter_period' and fiscalyear_id:
start_period = end_period = False
cr.execute('''
SELECT * FROM (SELECT p.id
FROM account_period p
LEFT JOIN account_fiscalyear f ON (p.fiscalyear_id = f.id)
LEFT JOIN account_fiscalyear f
ON (p.fiscalyear_id = f.id)
WHERE f.id = %s
AND COALESCE(p.special, FALSE) = FALSE
ORDER BY p.date_start ASC
@ -114,18 +131,21 @@ class AccountReportGeneralLedgerWizard(orm.TransientModel):
UNION ALL
SELECT * FROM (SELECT p.id
FROM account_period p
LEFT JOIN account_fiscalyear f ON (p.fiscalyear_id = f.id)
LEFT JOIN account_fiscalyear f
ON (p.fiscalyear_id = f.id)
WHERE f.id = %s
AND p.date_start < NOW()
AND COALESCE(p.special, FALSE) = FALSE
ORDER BY p.date_stop DESC
LIMIT 1) AS period_stop''', (fiscalyear_id, fiscalyear_id))
LIMIT 1) AS period_stop''',
(fiscalyear_id, fiscalyear_id))
periods = [i[0] for i in cr.fetchall()]
if periods:
start_period = end_period = periods[0]
if len(periods) > 1:
end_period = periods[1]
res['value'] = {'period_from': start_period, 'period_to': end_period, 'date_from': False, 'date_to': False}
res['value'] = {'period_from': start_period, 'period_to':
end_period, 'date_from': False, 'date_to': False}
return res
def _print_report(self, cursor, uid, ids, data, context=None):

99
account_financial_report_webkit/wizard/open_invoices_wizard.py
View File

@ -22,6 +22,7 @@ from openerp.osv import fields, orm
class AccountReportOpenInvoicesWizard(orm.TransientModel):
"""Will launch partner ledger report and pass required args"""
_inherit = "partners.ledger.webkit"
@ -30,20 +31,27 @@ class AccountReportOpenInvoicesWizard(orm.TransientModel):
_columns = {
'group_by_currency': fields.boolean('Group Partner by currency'),
'until_date': fields.date("Clearance date",
required=True,
help="""The clearance date is essentially a tool used for debtors provisionning calculation.
'until_date': fields.date(
"Clearance date",
required=True,
help="""The clearance date is essentially a tool used for debtors
provisionning calculation.
By default, this date is equal to the the end date (ie: 31/12/2011 if you select fy 2011).
By default, this date is equal to the the end date (ie: 31/12/2011 if you
select fy 2011).
By amending the clearance date, you will be, for instance, able to answer the question : 'based on my last year end debtors open invoices, which invoices are still unpaid today (today is my clearance date)?'
By amending the clearance date, you will be, for instance, able to answer the
question : 'based on my last year end debtors open invoices, which invoices
are still unpaid today (today is my clearance date)?'
""")}
def _check_until_date(self, cr, uid, ids, context=None):
def get_key_id(obj, field):
return obj.get(field) and obj[field][0] or False
obj = self.read(cr, uid, ids[0], ['fiscalyear_id', 'period_to', 'date_to', 'until_date'], context=context)
obj = self.read(cr, uid, ids[0], [
'fiscalyear_id', 'period_to', 'date_to', 'until_date'],
context=context)
min_date = self.default_until_date(cr, uid, ids,
get_key_id(obj, 'fiscalyear_id'),
get_key_id(obj, 'period_to'),
@ -54,59 +62,78 @@ By amending the clearance date, you will be, for instance, able to answer the qu
return True
_constraints = [
(_check_until_date, 'Clearance date must be the very last date of the last period or later.', ['until_date']),
(_check_until_date, 'Clearance date must be the very last date of the \
last period or later.', ['until_date']),
]
def default_until_date(self, cr, uid, ids, fiscalyear_id=False, period_id=False, date_to=False, context=None):
def default_until_date(self, cr, uid, ids, fiscalyear_id=False,
period_id=False, date_to=False, context=None):
res_date = False
# first priority: period or date filters
if period_id:
res_date = self.pool.get('account.period').read(cr, uid, period_id, ['date_stop'], context=context)['date_stop']
res_date = self.pool.get('account.period').read(
cr, uid, period_id, ['date_stop'],
context=context)['date_stop']
elif date_to:
res_date = date_to
elif fiscalyear_id:
res_date = self.pool.get('account.fiscalyear').read(cr, uid, fiscalyear_id, ['date_stop'], context=context)['date_stop']
res_date = self.pool.get('account.fiscalyear').read(
cr, uid, fiscalyear_id, ['date_stop'],
context=context)['date_stop']
return res_date
def onchange_fiscalyear(self, cr, uid, ids, fiscalyear=False, period_id=False, date_to=False, until_date=False, context=None):
def onchange_fiscalyear(self, cr, uid, ids, fiscalyear=False,
period_id=False, date_to=False, until_date=False,
context=None):
res = {'value': {}}
res['value']['until_date'] = self.default_until_date(cr, uid, ids,
fiscalyear_id=fiscalyear,
period_id=period_id,
date_to=date_to,
context=context)
res['value']['until_date'] = self.default_until_date(
cr, uid, ids,
fiscalyear_id=fiscalyear,
period_id=period_id,
date_to=date_to,
context=context)
return res
def onchange_date_to(self, cr, uid, ids, fiscalyear=False, period_id=False, date_to=False, until_date=False, context=None):
def onchange_date_to(self, cr, uid, ids, fiscalyear=False, period_id=False,
date_to=False, until_date=False, context=None):
res = {'value': {}}
res['value']['until_date'] = self.default_until_date(cr, uid, ids,
fiscalyear_id=fiscalyear,
period_id=period_id,
date_to=date_to,
context=context)
res['value']['until_date'] = self.default_until_date(
cr, uid, ids,
fiscalyear_id=fiscalyear,
period_id=period_id,
date_to=date_to,
context=context)
return res
def onchange_period_to(self, cr, uid, ids, fiscalyear=False, period_id=False, date_to=False, until_date=False, context=None):
def onchange_period_to(self, cr, uid, ids, fiscalyear=False,
period_id=False, date_to=False, until_date=False,
context=None):
res = {'value': {}}
res['value']['until_date'] = self.default_until_date(cr, uid, ids,
fiscalyear_id=fiscalyear,
period_id=period_id,
date_to=date_to,
context=context)
res['value']['until_date'] = self.default_until_date(
cr, uid, ids,
fiscalyear_id=fiscalyear,
period_id=period_id,
date_to=date_to,
context=context)
return res
def onchange_filter(self, cr, uid, ids, filter='filter_no', fiscalyear_id=False, context=None):
res = super(AccountReportOpenInvoicesWizard, self).onchange_filter(cr, uid, ids, filter=filter, fiscalyear_id=fiscalyear_id, context=context)
def onchange_filter(self, cr, uid, ids, filter='filter_no',
fiscalyear_id=False, context=None):
res = super(AccountReportOpenInvoicesWizard, self).onchange_filter(
cr, uid, ids, filter=filter, fiscalyear_id=fiscalyear_id,
context=context)
if res.get('value', False):
res['value']['until_date'] = self.default_until_date(cr, uid, ids,
fiscalyear_id=fiscalyear_id,
period_id=res['value'].get('period_to', False),
date_to=res['value'].get('date_to', False),
context=context)
res['value']['until_date'] = self.default_until_date(
cr, uid, ids,
fiscalyear_id=fiscalyear_id,
period_id=res['value'].get('period_to', False),
date_to=res['value'].get('date_to', False),
context=context)
return res
def pre_print_report(self, cr, uid, ids, data, context=None):
data = super(AccountReportOpenInvoicesWizard, self).pre_print_report(cr, uid, ids, data, context)
data = super(AccountReportOpenInvoicesWizard, self).pre_print_report(
cr, uid, ids, data, context)
vals = self.read(cr, uid, ids,
['until_date', 'group_by_currency'],
context=context)[0]

19
account_financial_report_webkit/wizard/partner_balance_wizard.py
View File

@ -23,6 +23,7 @@ from openerp.osv import fields, orm
class AccountPartnerBalanceWizard(orm.TransientModel):
"""Will launch partner balance report and pass required args"""
_inherit = "account.common.balance.report"
@ -30,12 +31,15 @@ class AccountPartnerBalanceWizard(orm.TransientModel):
_description = "Partner Balance Report"
_columns = {
'result_selection': fields.selection([('customer', 'Receivable Accounts'),
('supplier', 'Payable Accounts'),
('customer_supplier', 'Receivable and Payable Accounts')],
"Partner's", required=True),
'partner_ids': fields.many2many('res.partner', string='Filter on partner',
help="Only selected partners will be printed. Leave empty to print all partners."),
'result_selection': fields.selection(
[('customer', 'Receivable Accounts'),
('supplier', 'Payable Accounts'),
('customer_supplier', 'Receivable and Payable Accounts')],
"Partner's", required=True),
'partner_ids': fields.many2many(
'res.partner', string='Filter on partner',
help="Only selected partners will be printed. \
Leave empty to print all partners."),
}
_defaults = {
@ -43,7 +47,8 @@ class AccountPartnerBalanceWizard(orm.TransientModel):
}
def pre_print_report(self, cr, uid, ids, data, context=None):
data = super(AccountPartnerBalanceWizard, self).pre_print_report(cr, uid, ids, data, context)
data = super(AccountPartnerBalanceWizard, self).\
pre_print_report(cr, uid, ids, data, context)
vals = self.read(cr, uid, ids,
['result_selection', 'partner_ids'],
context=context)[0]

60
account_financial_report_webkit/wizard/partners_ledger_wizard.py
View File

@ -24,6 +24,7 @@ from openerp.osv import fields, orm
class AccountReportPartnersLedgerWizard(orm.TransientModel):
"""Will launch partner ledger report and pass required args"""
_inherit = "account.common.partner.report"
@ -33,14 +34,18 @@ class AccountReportPartnersLedgerWizard(orm.TransientModel):
_columns = {
'amount_currency': fields.boolean("With Currency",
help="It adds the currency column"),
'partner_ids': fields.many2many('res.partner', string='Filter on partner',
help="Only selected partners will be printed. "
"Leave empty to print all partners."),
'filter': fields.selection([('filter_no', 'No Filters'),
('filter_date', 'Date'),
('filter_period', 'Periods')], "Filter by", required=True,
help='Filter by date: no opening balance will be displayed. '
'(opening balance can only be computed based on period to be correct).'),
'partner_ids': fields.many2many(
'res.partner',
string='Filter on partner',
help="Only selected partners will be printed. "
"Leave empty to print all partners."),
'filter': fields.selection(
[('filter_no', 'No Filters'),
('filter_date', 'Date'),
('filter_period', 'Periods')], "Filter by", required=True,
help='Filter by date: no opening balance will be displayed. '
'(opening balance can only be computed based on period to be \
correct).'),
}
_defaults = {
'amount_currency': False,
@ -48,7 +53,8 @@ class AccountReportPartnersLedgerWizard(orm.TransientModel):
}
def _check_fiscalyear(self, cr, uid, ids, context=None):
obj = self.read(cr, uid, ids[0], ['fiscalyear_id', 'filter'], context=context)
obj = self.read(
cr, uid, ids[0], ['fiscalyear_id', 'filter'], context=context)
if not obj['fiscalyear_id'] and obj['filter'] == 'filter_no':
return False
return True
@ -60,25 +66,35 @@ class AccountReportPartnersLedgerWizard(orm.TransientModel):
['filter']),
]
def onchange_filter(self, cr, uid, ids, filter='filter_no', fiscalyear_id=False, context=None):
def onchange_filter(self, cr, uid, ids, filter='filter_no',
fiscalyear_id=False, context=None):
res = {}
if filter == 'filter_no':
res['value'] = {'period_from': False, 'period_to': False, 'date_from': False, 'date_to': False}
res['value'] = {'period_from': False,
'period_to': False,
'date_from': False,
'date_to': False}
if filter == 'filter_date':
if fiscalyear_id:
fyear = self.pool.get('account.fiscalyear').browse(cr, uid, fiscalyear_id, context=context)
fyear = self.pool.get('account.fiscalyear').browse(
cr, uid, fiscalyear_id, context=context)
date_from = fyear.date_start
date_to = fyear.date_stop > time.strftime('%Y-%m-%d') and time.strftime('%Y-%m-%d') or fyear.date_stop
date_to = fyear.date_stop > time.strftime(
'%Y-%m-%d') and time.strftime('%Y-%m-%d') \
or fyear.date_stop
else:
date_from, date_to = time.strftime('%Y-01-01'), time.strftime('%Y-%m-%d')
res['value'] = {'period_from': False, 'period_to': False, 'date_from': date_from, 'date_to': date_to}
date_from, date_to = time.strftime(
'%Y-01-01'), time.strftime('%Y-%m-%d')
res['value'] = {'period_from': False, 'period_to':
False, 'date_from': date_from, 'date_to': date_to}
if filter == 'filter_period' and fiscalyear_id:
start_period = end_period = False
cr.execute('''
SELECT * FROM (SELECT p.id
FROM account_period p
LEFT JOIN account_fiscalyear f ON (p.fiscalyear_id = f.id)
LEFT JOIN account_fiscalyear f
ON (p.fiscalyear_id = f.id)
WHERE f.id = %s
AND COALESCE(p.special, FALSE) = FALSE
ORDER BY p.date_start ASC
@ -86,22 +102,26 @@ class AccountReportPartnersLedgerWizard(orm.TransientModel):
UNION ALL
SELECT * FROM (SELECT p.id
FROM account_period p
LEFT JOIN account_fiscalyear f ON (p.fiscalyear_id = f.id)
LEFT JOIN account_fiscalyear f
ON (p.fiscalyear_id = f.id)
WHERE f.id = %s
AND p.date_start < NOW()
AND COALESCE(p.special, FALSE) = FALSE
ORDER BY p.date_stop DESC
LIMIT 1) AS period_stop''', (fiscalyear_id, fiscalyear_id))
LIMIT 1) AS period_stop''',
(fiscalyear_id, fiscalyear_id))
periods = [i[0] for i in cr.fetchall()]
if periods:
start_period = end_period = periods[0]
if len(periods) > 1:
end_period = periods[1]
res['value'] = {'period_from': start_period, 'period_to': end_period, 'date_from': False, 'date_to': False}
res['value'] = {'period_from': start_period, 'period_to':
end_period, 'date_from': False, 'date_to': False}
return res
def pre_print_report(self, cr, uid, ids, data, context=None):
data = super(AccountReportPartnersLedgerWizard, self).pre_print_report(cr, uid, ids, data, context)
data = super(AccountReportPartnersLedgerWizard, self).pre_print_report(
cr, uid, ids, data, context)
if context is None:
context = {}
# will be used to attach the report on the main account

63
account_financial_report_webkit/wizard/print_journal.py
View File

@ -7,13 +7,13 @@
#
# This file is a part of account_financial_report_webkit
#
# account_financial_report_webkit is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# account_financial_report_webkit is free software: you can redistribute it
# and/or modify it under the terms of the GNU Affero General Public License
# as published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# account_financial_report_webkit is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# account_financial_report_webkit is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
@ -24,10 +24,10 @@
from openerp.osv import fields, orm
import time
from lxml import etree
class AccountReportPrintJournalWizard(orm.TransientModel):
"""Will launch print journal report and pass requiered args"""
_inherit = "account.common.account.report"
@ -35,7 +35,8 @@ class AccountReportPrintJournalWizard(orm.TransientModel):
_description = "Journals Report"
_columns = {
'amount_currency': fields.boolean("With Currency", help="It adds the currency column"),
'amount_currency': fields.boolean("With Currency",
help="It adds the currency column"),
}
_defaults = {
@ -45,17 +46,20 @@ class AccountReportPrintJournalWizard(orm.TransientModel):
}
def _check_fiscalyear(self, cr, uid, ids, context=None):
obj = self.read(cr, uid, ids[0], ['fiscalyear_id', 'filter'], context=context)
obj = self.read(cr, uid, ids[0], ['fiscalyear_id', 'filter'],
context=context)
if not obj['fiscalyear_id'] and obj['filter'] == 'filter_no':
return False
return True
_constraints = [
(_check_fiscalyear, 'When no Fiscal year is selected, you must choose to filter by periods or by date.', ['filter']),
(_check_fiscalyear, 'When no Fiscal year is selected, you must choose \
to filter by periods or by date.', ['filter']),
]
def pre_print_report(self, cr, uid, ids, data, context=None):
data = super(AccountReportPrintJournalWizard, self).pre_print_report(cr, uid, ids, data, context)
data = super(AccountReportPrintJournalWizard, self).\
pre_print_report(cr, uid, ids, data, context)
# will be used to attach the report on the main account
data['ids'] = [data['form']['chart_account_id']]
vals = self.read(cr, uid, ids,
@ -66,24 +70,34 @@ class AccountReportPrintJournalWizard(orm.TransientModel):
data['form'].update(vals)
return data
def onchange_filter(self, cr, uid, ids, filter='filter_no', fiscalyear_id=False, context=None):
def onchange_filter(self, cr, uid, ids, filter='filter_no',
fiscalyear_id=False, context=None):
res = {}
if filter == 'filter_no':
res['value'] = {'period_from': False, 'period_to': False, 'date_from': False, 'date_to': False}
res['value'] = {'period_from': False,
'period_to': False,
'date_from': False,
'date_to': False}
if filter == 'filter_date':
if fiscalyear_id:
fyear = self.pool.get('account.fiscalyear').browse(cr, uid, fiscalyear_id, context=context)
fyear = self.pool.get('account.fiscalyear').browse(
cr, uid, fiscalyear_id, context=context)
date_from = fyear.date_start
date_to = fyear.date_stop > time.strftime('%Y-%m-%d') and time.strftime('%Y-%m-%d') or fyear.date_stop
date_to = fyear.date_stop > time.strftime(
'%Y-%m-%d') and time.strftime('%Y-%m-%d') \
or fyear.date_stop
else:
date_from, date_to = time.strftime('%Y-01-01'), time.strftime('%Y-%m-%d')
res['value'] = {'period_from': False, 'period_to': False, 'date_from': date_from, 'date_to': date_to}
date_from, date_to = time.strftime(
'%Y-01-01'), time.strftime('%Y-%m-%d')
res['value'] = {'period_from': False, 'period_to':
False, 'date_from': date_from, 'date_to': date_to}
if filter == 'filter_period' and fiscalyear_id:
start_period = end_period = False
cr.execute('''
SELECT * FROM (SELECT p.id
FROM account_period p
LEFT JOIN account_fiscalyear f ON (p.fiscalyear_id = f.id)
LEFT JOIN account_fiscalyear f
ON (p.fiscalyear_id = f.id)
WHERE f.id = %s
AND COALESCE(p.special, FALSE) = FALSE
ORDER BY p.date_start ASC
@ -91,18 +105,21 @@ class AccountReportPrintJournalWizard(orm.TransientModel):
UNION ALL
SELECT * FROM (SELECT p.id
FROM account_period p
LEFT JOIN account_fiscalyear f ON (p.fiscalyear_id = f.id)
LEFT JOIN account_fiscalyear f
ON (p.fiscalyear_id = f.id)
WHERE f.id = %s
AND p.date_start < NOW()
AND COALESCE(p.special, FALSE) = FALSE
ORDER BY p.date_stop DESC
LIMIT 1) AS period_stop''', (fiscalyear_id, fiscalyear_id))
LIMIT 1) AS period_stop''',
(fiscalyear_id, fiscalyear_id))
periods = [i[0] for i in cr.fetchall()]
if periods:
start_period = end_period = periods[0]
if len(periods) > 1:
end_period = periods[1]
res['value'] = {'period_from': start_period, 'period_to': end_period, 'date_from': False, 'date_to': False}
res['value'] = {'period_from': start_period, 'period_to':
end_period, 'date_from': False, 'date_to': False}
return res
def _print_report(self, cursor, uid, ids, data, context=None):
@ -112,7 +129,3 @@ class AccountReportPrintJournalWizard(orm.TransientModel):
return {'type': 'ir.actions.report.xml',
'report_name': 'account.account_report_print_journal_webkit',
'datas': data}
AccountReportPrintJournalWizard()
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

2
account_financial_report_webkit/wizard/trial_balance_wizard.py
View File

@ -37,5 +37,3 @@ class AccountTrialBalanceWizard(orm.TransientModel):
return {'type': 'ir.actions.report.xml',
'report_name': 'account.account_report_trial_balance_webkit',
'datas': data}
AccountTrialBalanceWizard()