You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
251 lines
12 KiB
251 lines
12 KiB
# -*- encoding: utf-8 -*-
|
|
##############################################################################
|
|
#
|
|
# Author: Nicolas Bessi, Guewen Baconnier
|
|
# Copyright Camptocamp SA 2011
|
|
# SQL inspired from OpenERP original code
|
|
#
|
|
# This program 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.
|
|
#
|
|
# This program 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.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
##############################################################################
|
|
# TODO refactor helper in order to act more like mixin
|
|
# By using properties we will have a more simple signature in fuctions
|
|
|
|
from collections import defaultdict
|
|
|
|
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,
|
|
exclude_reconcile=False, partner_filter=False):
|
|
filter_from = False
|
|
if main_filter in ('filter_period', 'filter_no'):
|
|
filter_from = 'period'
|
|
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)
|
|
|
|
def _get_query_params_from_periods(self, period_start, period_stop, mode='exclude_opening'):
|
|
# 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)
|
|
if not periods:
|
|
return []
|
|
|
|
if mode == 'exclude_opening':
|
|
periods = self.exclude_opening_periods(periods)
|
|
|
|
search_params = {'period_ids': tuple(periods),
|
|
'date_stop': period_stop.date_stop}
|
|
|
|
sql_conditions = " AND account_move_line.period_id in %(period_ids)s"
|
|
|
|
return sql_conditions, search_params
|
|
|
|
def _get_query_params_from_dates(self, date_start, date_stop, **args):
|
|
|
|
periods = self._get_opening_periods()
|
|
if not periods:
|
|
periods = (-1,)
|
|
|
|
search_params = {'period_ids': tuple(periods),
|
|
'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))"
|
|
|
|
return sql_conditions, search_params
|
|
|
|
def _get_partners_move_line_ids(self, filter_from, account_id, start, stop, target_move, opening_mode='include_opening',
|
|
exclude_reconcile=False, partner_filter=False):
|
|
|
|
final_res = defaultdict(list)
|
|
|
|
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' "
|
|
|
|
sql_conditions, search_params = getattr(self, '_get_query_params_from_'+filter_from+'s')(start, stop, mode=opening_mode)
|
|
|
|
sql_where += sql_conditions
|
|
|
|
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)))")
|
|
|
|
if partner_filter:
|
|
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_where += " AND account_move.state = %(target_move)s"
|
|
search_params.update({'target_move': target_move,})
|
|
|
|
search_params.update({
|
|
'account_ids': account_id,
|
|
'partner_ids': tuple(partner_filter),
|
|
})
|
|
|
|
sql = ' '.join((sql_select, sql_joins, sql_where))
|
|
self.cursor.execute(sql, search_params)
|
|
res = self.cursor.dictfetchall()
|
|
if res:
|
|
for row in res:
|
|
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):
|
|
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"
|
|
self.cursor.execute(sql, (tuple(move_line_ids),))
|
|
rec_ids = self.cursor.fetchall()
|
|
if rec_ids:
|
|
rec_ids = [x[0] for x in rec_ids]
|
|
l_ids = move_line_obj.search(self.cursor,
|
|
self.uid,
|
|
[('reconcile_id', 'in', rec_ids),
|
|
('date', '>=', date_stop),
|
|
('date', '<=', date_until)])
|
|
return l_ids
|
|
else:
|
|
return []
|
|
|
|
####################Initial Partner Balance helper ########################
|
|
|
|
def _tree_move_line_ids(self, move_lines_data, key=None):
|
|
"""
|
|
move_lines_data must be a list of dict which contains at least keys :
|
|
- account_id
|
|
- partner_id
|
|
- other keys with values of the line
|
|
- if param key is defined, only this key will be inserted in the tree
|
|
returns a tree like
|
|
res[account_id.1][partner_id.1][move_line.1,
|
|
move_line.2]
|
|
[partner_id.2][move_line.3]
|
|
res[account_id.2][partner_id.1][move_line.4]
|
|
"""
|
|
res = defaultdict(dict)
|
|
for row in move_lines_data[:]:
|
|
account_id = row.pop('account_id')
|
|
partner_id = row.pop('partner_id')
|
|
if key:
|
|
res[account_id].setdefault(partner_id, []).append(row[key])
|
|
else:
|
|
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):
|
|
# 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 not period_ids:
|
|
period_ids = [-1]
|
|
search_param = {'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 "
|
|
"ON a.id = ml.account_id "
|
|
"WHERE ml.period_id in %(period_ids)s "
|
|
"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.")
|
|
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))) ")
|
|
if partner_filter:
|
|
sql += "AND ml.partner_id in %(partner_ids)s "
|
|
search_param.update({'partner_ids': tuple(partner_filter)})
|
|
|
|
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):
|
|
"""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 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)
|
|
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, "
|
|
" c.name as currency_name "
|
|
"FROM account_move_line ml "
|
|
"INNER JOIN account_account a "
|
|
"ON a.id = ml.account_id "
|
|
"LEFT JOIN res_currency c "
|
|
"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])}
|
|
self.cursor.execute(sql, search_param)
|
|
res = self.cursor.dictfetchall()
|
|
return self._tree_move_line_ids(res)
|
|
|
|
####################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
|
|
args must be list"""
|
|
res = []
|
|
partner_ids = []
|
|
for arg in args:
|
|
if arg:
|
|
partner_ids += arg
|
|
if not partner_ids:
|
|
return []
|
|
|
|
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 name, ref")
|
|
self.cursor.execute(sql, (tuple(set(existing_partner_ids)),))
|
|
res = self.cursor.fetchall()
|
|
|
|
# move lines without partners, set None for empty partner
|
|
if not all(partner_ids):
|
|
res.append((None, None, None, None))
|
|
|
|
if not res:
|
|
return []
|
|
return res
|