Techsystech
/
OCA_Reporting_engine_17.0
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[IMP] report_xlsx_helper: black, isort

pull/456/head
kongrattapong 2020-01-09 11:26:17 +07:00 committed by Saran440
parent 1aaff5ac48
commit f33e647a26
7 changed files with 494 additions and 407 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
report_xlsx_helper/__manifest__.py
View File

@ -2,15 +2,12 @@
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{ {
'name': 'Report xlsx helpers', "name": "Report xlsx helpers",
'author': 'Noviat,' "author": "Noviat," "Odoo Community Association (OCA)",
'Odoo Community Association (OCA)', "website": "https://github.com/OCA/reporting-engine",
'website': 'https://github.com/OCA/reporting-engine', "category": "Reporting",
'category': 'Reporting', "version": "12.0.1.1.1",
'version': '12.0.1.1.1', "license": "AGPL-3",
'license': 'AGPL-3', "depends": ["report_xlsx"],
'depends': [ "installable": True,
'report_xlsx',
],
'installable': True,
} }

65
report_xlsx_helper/controllers/main.py
View File

@ -3,52 +3,55 @@
import json import json
from odoo.http import content_disposition, request, route
from odoo.addons.report_xlsx.controllers.main import ReportController from odoo.addons.report_xlsx.controllers.main import ReportController
from odoo.http import content_disposition, route, request
class ReportController(ReportController): class ReportController(ReportController):
@route(
@route([ [
'/report/<converter>/<reportname>', "/report/<converter>/<reportname>",
'/report/<converter>/<reportname>/<docids>', "/report/<converter>/<reportname>/<docids>",
], type='http', auth='user', website=True) ],
type="http",
auth="user",
website=True,
)
def report_routes(self, reportname, docids=None, converter=None, **data): def report_routes(self, reportname, docids=None, converter=None, **data):
report = request.env['ir.actions.report']._get_report_from_name( report = request.env["ir.actions.report"]._get_report_from_name(reportname)
reportname) if converter == "xlsx" and not report:
if converter == 'xlsx' and not report:
context = dict(request.env.context) context = dict(request.env.context)
if docids: if docids:
docids = [int(i) for i in docids.split(',')] docids = [int(i) for i in docids.split(",")]
if data.get('options'): if data.get("options"):
data.update(json.loads(data.pop('options'))) data.update(json.loads(data.pop("options")))
if data.get('context'): if data.get("context"):
# Ignore 'lang' here, because the context in data is the one # Ignore 'lang' here, because the context in data is the one
# from the webclient *but* if the user explicitely wants to # from the webclient *but* if the user explicitely wants to
# change the lang, this mechanism overwrites it. # change the lang, this mechanism overwrites it.
data['context'] = json.loads(data['context']) data["context"] = json.loads(data["context"])
if data['context'].get('lang'): if data["context"].get("lang"):
del data['context']['lang'] del data["context"]["lang"]
context.update(data['context']) context.update(data["context"])
context['report_name'] = reportname context["report_name"] = reportname
xlsx = report.with_context(context).render_xlsx( xlsx = report.with_context(context).render_xlsx(docids, data=data)[0]
docids, data=data report_file = context.get("report_file")
)[0]
report_file = context.get('report_file')
if not report_file: if not report_file:
active_model = context.get('active_model', 'export') active_model = context.get("active_model", "export")
report_file = active_model.replace('.', '_') report_file = active_model.replace(".", "_")
xlsxhttpheaders = [ xlsxhttpheaders = [
('Content-Type', 'application/vnd.openxmlformats-'
'officedocument.spreadsheetml.sheet'),
('Content-Length', len(xlsx)),
( (
'Content-Disposition', "Content-Type",
content_disposition(report_file + '.xlsx') "application/vnd.openxmlformats-"
) "officedocument.spreadsheetml.sheet",
),
("Content-Length", len(xlsx)),
("Content-Disposition", content_disposition(report_file + ".xlsx")),
] ]
return request.make_response(xlsx, headers=xlsxhttpheaders) return request.make_response(xlsx, headers=xlsxhttpheaders)
return super(ReportController, self).report_routes( return super(ReportController, self).report_routes(
reportname, docids, converter, **data) reportname, docids, converter, **data
)

12
report_xlsx_helper/models/ir_actions_report.py
View File

@ -1,21 +1,19 @@
# Copyright 2009-2018 Noviat. # Copyright 2009-2018 Noviat.
# License AGPL-3.0 or later (https://www.gnuorg/licenses/agpl.html). # License AGPL-3.0 or later (https://www.gnuorg/licenses/agpl.html).
from odoo import api, models, _ from odoo import _, api, models
from odoo.exceptions import UserError from odoo.exceptions import UserError
class IrActionsReport(models.Model): class IrActionsReport(models.Model):
_inherit = 'ir.actions.report' _inherit = "ir.actions.report"
@api.model @api.model
def render_xlsx(self, docids, data): def render_xlsx(self, docids, data):
if not self and self.env.context.get('report_name'): if not self and self.env.context.get("report_name"):
report_model_name = 'report.{}'.format( report_model_name = "report.{}".format(self.env.context["report_name"])
self.env.context['report_name'])
report_model = self.env.get(report_model_name) report_model = self.env.get(report_model_name)
if report_model is None: if report_model is None:
raise UserError( raise UserError(_("%s model was not found" % report_model_name))
_('%s model was not found' % report_model_name))
return report_model.create_xlsx_report(docids, data) return report_model.create_xlsx_report(docids, data)
return super(IrActionsReport, self).render_xlsx(docids, data) return super(IrActionsReport, self).render_xlsx(docids, data)

2
report_xlsx_helper/readme/DESCRIPTION.rst
View File

@ -1 +1 @@
This module provides a set of tools to facilitate the creation of excel reports with format xlsx. This module provides a set of tools to facilitate the creation of excel reports with format xlsx.

680
report_xlsx_helper/report/report_xlsx_abstract.py
View File

@ -1,49 +1,55 @@
# Copyright 2009-2018 Noviat. # Copyright 2009-2018 Noviat.
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl). # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from datetime import datetime, date
import re import re
from datetime import date, datetime
from types import CodeType from types import CodeType
from xlsxwriter.utility import xl_rowcol_to_cell from xlsxwriter.utility import xl_rowcol_to_cell
from odoo import fields, models, _ from odoo import _, fields, models
from odoo.exceptions import UserError from odoo.exceptions import UserError
class ReportXlsxAbstract(models.AbstractModel): class ReportXlsxAbstract(models.AbstractModel):
_inherit = 'report.report_xlsx.abstract' _inherit = "report.report_xlsx.abstract"
def generate_xlsx_report(self, workbook, data, objects): def generate_xlsx_report(self, workbook, data, objects):
self._define_formats(workbook) self._define_formats(workbook)
for ws_params in self._get_ws_params(workbook, data, objects): for ws_params in self._get_ws_params(workbook, data, objects):
ws_name = ws_params.get('ws_name') ws_name = ws_params.get("ws_name")
ws_name = self._check_ws_name(ws_name) ws_name = self._check_ws_name(ws_name)
ws = workbook.add_worksheet(ws_name) ws = workbook.add_worksheet(ws_name)
generate_ws_method = getattr( generate_ws_method = getattr(self, ws_params["generate_ws_method"])
self, ws_params['generate_ws_method'])
generate_ws_method(workbook, ws, ws_params, data, objects) generate_ws_method(workbook, ws, ws_params, data, objects)
def _check_ws_name(self, name, sanitize=True): def _check_ws_name(self, name, sanitize=True):
pattern = re.compile(r'[/\\*\[\]:?]') # invalid characters: /\*[]:? pattern = re.compile(r"[/\\*\[\]:?]") # invalid characters: /\*[]:?
max_chars = 31 max_chars = 31
if sanitize: if sanitize:
# we could drop these two lines since a similar # we could drop these two lines since a similar
# sanitize is done in tools.misc PatchedXlsxWorkbook # sanitize is done in tools.misc PatchedXlsxWorkbook
name = pattern.sub('', name) name = pattern.sub("", name)
name = name[:max_chars] name = name[:max_chars]
else: else:
if len(name) > max_chars: if len(name) > max_chars:
raise UserError(_( raise UserError(
"Programming Error:\n\n" _(
"Excel Sheet name '%s' should not exceed %s characters." "Programming Error:\n\n"
) % (name, max_chars)) "Excel Sheet name '%s' should not exceed %s characters."
)
% (name, max_chars)
)
special_chars = pattern.findall(name) special_chars = pattern.findall(name)
if special_chars: if special_chars:
raise UserError(_( raise UserError(
"Programming Error:\n\n" _(
"Excel Sheet name '%s' contains unsupported special " "Programming Error:\n\n"
"characters: '%s'." "Excel Sheet name '%s' contains unsupported special "
) % (name, special_chars)) "characters: '%s'."
)
% (name, special_chars)
)
return name return name
def _get_ws_params(self, workbook, data, objects): def _get_ws_params(self, workbook, data, objects):
@ -68,19 +74,20 @@ class ReportXlsxAbstract(models.AbstractModel):
Predefined worksheet headers/footers. Predefined worksheet headers/footers.
""" """
hf_params = { hf_params = {
'font_size': 8, "font_size": 8,
'font_style': 'I', # B: Bold, I: Italic, U: Underline "font_style": "I", # B: Bold, I: Italic, U: Underline
}
self.xls_headers = {
'standard': ''
} }
self.xls_headers = {"standard": ""}
report_date = fields.Datetime.context_timestamp( report_date = fields.Datetime.context_timestamp(
self.env.user, datetime.now()).strftime('%Y-%m-%d %H:%M') self.env.user, datetime.now()
).strftime("%Y-%m-%d %H:%M")
self.xls_footers = { self.xls_footers = {
'standard': ( "standard": (
'&L&%(font_size)s&%(font_style)s' + report_date + "&L&%(font_size)s&%(font_style)s"
'&R&%(font_size)s&%(font_style)s&P / &N' + report_date
) % hf_params, + "&R&%(font_size)s&%(font_style)s&P / &N"
)
% hf_params
} }
def _define_formats(self, workbook): def _define_formats(self, workbook):
@ -91,355 +98,443 @@ class ReportXlsxAbstract(models.AbstractModel):
""" """
self._define_xls_headers(workbook) self._define_xls_headers(workbook)
border_grey = '#D3D3D3' border_grey = "#D3D3D3"
border = {'border': True, 'border_color': border_grey} border = {"border": True, "border_color": border_grey}
theader = dict(border, bold=True) theader = dict(border, bold=True)
bg_yellow = '#FFFFCC' bg_yellow = "#FFFFCC"
bg_blue = '#CCFFFF' bg_blue = "#CCFFFF"
num_format = '#,##0.00' num_format = "#,##0.00"
num_format_conditional = '{0};[Red]-{0};{0}'.format(num_format) num_format_conditional = "{0};[Red]-{0};{0}".format(num_format)
pct_format = '#,##0.00%' pct_format = "#,##0.00%"
pct_format_conditional = '{0};[Red]-{0};{0}'.format(pct_format) pct_format_conditional = "{0};[Red]-{0};{0}".format(pct_format)
int_format = '#,##0' int_format = "#,##0"
int_format_conditional = '{0};[Red]-{0};{0}'.format(int_format) int_format_conditional = "{0};[Red]-{0};{0}".format(int_format)
date_format = 'YYYY-MM-DD' date_format = "YYYY-MM-DD"
theader_yellow = dict(theader, bg_color=bg_yellow) theader_yellow = dict(theader, bg_color=bg_yellow)
theader_blue = dict(theader, bg_color=bg_blue) theader_blue = dict(theader, bg_color=bg_blue)
# format for worksheet title # format for worksheet title
self.format_ws_title = workbook.add_format( self.format_ws_title = workbook.add_format({"bold": True, "font_size": 14})
{'bold': True, 'font_size': 14})
# no border formats # no border formats
self.format_left = workbook.add_format({'align': 'left'}) self.format_left = workbook.add_format({"align": "left"})
self.format_center = workbook.add_format({'align': 'center'}) self.format_center = workbook.add_format({"align": "center"})
self.format_right = workbook.add_format({'align': 'right'}) self.format_right = workbook.add_format({"align": "right"})
self.format_amount_left = workbook.add_format( self.format_amount_left = workbook.add_format(
{'align': 'left', 'num_format': num_format}) {"align": "left", "num_format": num_format}
)
self.format_amount_center = workbook.add_format( self.format_amount_center = workbook.add_format(
{'align': 'center', 'num_format': num_format}) {"align": "center", "num_format": num_format}
)
self.format_amount_right = workbook.add_format( self.format_amount_right = workbook.add_format(
{'align': 'right', 'num_format': num_format}) {"align": "right", "num_format": num_format}
)
self.format_amount_conditional_left = workbook.add_format( self.format_amount_conditional_left = workbook.add_format(
{'align': 'left', 'num_format': num_format_conditional}) {"align": "left", "num_format": num_format_conditional}
)
self.format_amount_conditional_center = workbook.add_format( self.format_amount_conditional_center = workbook.add_format(
{'align': 'center', 'num_format': num_format_conditional}) {"align": "center", "num_format": num_format_conditional}
)
self.format_amount_conditional_right = workbook.add_format( self.format_amount_conditional_right = workbook.add_format(
{'align': 'right', 'num_format': num_format_conditional}) {"align": "right", "num_format": num_format_conditional}
)
self.format_percent_left = workbook.add_format( self.format_percent_left = workbook.add_format(
{'align': 'left', 'num_format': pct_format}) {"align": "left", "num_format": pct_format}
)
self.format_percent_center = workbook.add_format( self.format_percent_center = workbook.add_format(
{'align': 'center', 'num_format': pct_format}) {"align": "center", "num_format": pct_format}
)
self.format_percent_right = workbook.add_format( self.format_percent_right = workbook.add_format(
{'align': 'right', 'num_format': pct_format}) {"align": "right", "num_format": pct_format}
)
self.format_percent_conditional_left = workbook.add_format( self.format_percent_conditional_left = workbook.add_format(
{'align': 'left', 'num_format': pct_format_conditional}) {"align": "left", "num_format": pct_format_conditional}
)
self.format_percent_conditional_center = workbook.add_format( self.format_percent_conditional_center = workbook.add_format(
{'align': 'center', 'num_format': pct_format_conditional}) {"align": "center", "num_format": pct_format_conditional}
)
self.format_percent_conditional_right = workbook.add_format( self.format_percent_conditional_right = workbook.add_format(
{'align': 'right', 'num_format': pct_format_conditional}) {"align": "right", "num_format": pct_format_conditional}
)
self.format_integer_left = workbook.add_format( self.format_integer_left = workbook.add_format(
{'align': 'left', 'num_format': int_format}) {"align": "left", "num_format": int_format}
)
self.format_integer_center = workbook.add_format( self.format_integer_center = workbook.add_format(
{'align': 'center', 'num_format': int_format}) {"align": "center", "num_format": int_format}
)
self.format_integer_right = workbook.add_format( self.format_integer_right = workbook.add_format(
{'align': 'right', 'num_format': int_format}) {"align": "right", "num_format": int_format}
)
self.format_integer_conditional_left = workbook.add_format( self.format_integer_conditional_left = workbook.add_format(
{'align': 'right', 'num_format': int_format_conditional}) {"align": "right", "num_format": int_format_conditional}
)
self.format_integer_conditional_center = workbook.add_format( self.format_integer_conditional_center = workbook.add_format(
{'align': 'center', 'num_format': int_format_conditional}) {"align": "center", "num_format": int_format_conditional}
)
self.format_integer_conditional_right = workbook.add_format( self.format_integer_conditional_right = workbook.add_format(
{'align': 'right', 'num_format': int_format_conditional}) {"align": "right", "num_format": int_format_conditional}
)
self.format_date_left = workbook.add_format( self.format_date_left = workbook.add_format(
{'align': 'left', 'num_format': date_format}) {"align": "left", "num_format": date_format}
)
self.format_date_center = workbook.add_format( self.format_date_center = workbook.add_format(
{'align': 'center', 'num_format': date_format}) {"align": "center", "num_format": date_format}
)
self.format_date_right = workbook.add_format( self.format_date_right = workbook.add_format(
{'align': 'right', 'num_format': date_format}) {"align": "right", "num_format": date_format}
)
self.format_left_bold = workbook.add_format( self.format_left_bold = workbook.add_format({"align": "left", "bold": True})
{'align': 'left', 'bold': True}) self.format_center_bold = workbook.add_format({"align": "center", "bold": True})
self.format_center_bold = workbook.add_format( self.format_right_bold = workbook.add_format({"align": "right", "bold": True})
{'align': 'center', 'bold': True})
self.format_right_bold = workbook.add_format(
{'align': 'right', 'bold': True})
self.format_amount_left_bold = workbook.add_format( self.format_amount_left_bold = workbook.add_format(
{'align': 'left', 'bold': True, 'num_format': num_format}) {"align": "left", "bold": True, "num_format": num_format}
)
self.format_amount_center_bold = workbook.add_format( self.format_amount_center_bold = workbook.add_format(
{'align': 'center', 'bold': True, 'num_format': num_format}) {"align": "center", "bold": True, "num_format": num_format}
)
self.format_amount_right_bold = workbook.add_format( self.format_amount_right_bold = workbook.add_format(
{'align': 'right', 'bold': True, 'num_format': num_format}) {"align": "right", "bold": True, "num_format": num_format}
)
self.format_amount_conditional_left_bold = workbook.add_format( self.format_amount_conditional_left_bold = workbook.add_format(
{'align': 'left', 'bold': True, {"align": "left", "bold": True, "num_format": num_format_conditional}
'num_format': num_format_conditional}) )
self.format_amount_conditional_center_bold = workbook.add_format( self.format_amount_conditional_center_bold = workbook.add_format(
{'align': 'center', 'bold': True, {"align": "center", "bold": True, "num_format": num_format_conditional}
'num_format': num_format_conditional}) )
self.format_amount_conditional_right_bold = workbook.add_format( self.format_amount_conditional_right_bold = workbook.add_format(
{'align': 'right', 'bold': True, {"align": "right", "bold": True, "num_format": num_format_conditional}
'num_format': num_format_conditional}) )
self.format_percent_left_bold = workbook.add_format( self.format_percent_left_bold = workbook.add_format(
{'align': 'left', 'bold': True, 'num_format': pct_format}) {"align": "left", "bold": True, "num_format": pct_format}
)
self.format_percent_center_bold = workbook.add_format( self.format_percent_center_bold = workbook.add_format(
{'align': 'center', 'bold': True, 'num_format': pct_format}) {"align": "center", "bold": True, "num_format": pct_format}
)
self.format_percent_right_bold = workbook.add_format( self.format_percent_right_bold = workbook.add_format(
{'align': 'right', 'bold': True, 'num_format': pct_format}) {"align": "right", "bold": True, "num_format": pct_format}
)
self.format_percent_conditional_left_bold = workbook.add_format( self.format_percent_conditional_left_bold = workbook.add_format(
{'align': 'left', 'bold': True, {"align": "left", "bold": True, "num_format": pct_format_conditional}
'num_format': pct_format_conditional}) )
self.format_percent_conditional_center_bold = workbook.add_format( self.format_percent_conditional_center_bold = workbook.add_format(
{'align': 'center', 'bold': True, {"align": "center", "bold": True, "num_format": pct_format_conditional}
'num_format': pct_format_conditional}) )
self.format_percent_conditional_right_bold = workbook.add_format( self.format_percent_conditional_right_bold = workbook.add_format(
{'align': 'right', 'bold': True, {"align": "right", "bold": True, "num_format": pct_format_conditional}
'num_format': pct_format_conditional}) )
self.format_integer_left_bold = workbook.add_format( self.format_integer_left_bold = workbook.add_format(
{'align': 'left', 'bold': True, 'num_format': int_format}) {"align": "left", "bold": True, "num_format": int_format}
)
self.format_integer_center_bold = workbook.add_format( self.format_integer_center_bold = workbook.add_format(
{'align': 'center', 'bold': True, 'num_format': int_format}) {"align": "center", "bold": True, "num_format": int_format}
)
self.format_integer_right_bold = workbook.add_format( self.format_integer_right_bold = workbook.add_format(
{'align': 'right', 'bold': True, 'num_format': int_format}) {"align": "right", "bold": True, "num_format": int_format}
)
self.format_integer_conditional_left_bold = workbook.add_format( self.format_integer_conditional_left_bold = workbook.add_format(
{'align': 'left', 'bold': True, {"align": "left", "bold": True, "num_format": int_format_conditional}
'num_format': int_format_conditional}) )
self.format_integer_conditional_center_bold = workbook.add_format( self.format_integer_conditional_center_bold = workbook.add_format(
{'align': 'center', 'bold': True, {"align": "center", "bold": True, "num_format": int_format_conditional}
'num_format': int_format_conditional}) )
self.format_integer_conditional_right_bold = workbook.add_format( self.format_integer_conditional_right_bold = workbook.add_format(
{'align': 'right', 'bold': True, {"align": "right", "bold": True, "num_format": int_format_conditional}
'num_format': int_format_conditional}) )
self.format_date_left_bold = workbook.add_format( self.format_date_left_bold = workbook.add_format(
{'align': 'left', 'bold': True, 'num_format': date_format}) {"align": "left", "bold": True, "num_format": date_format}
)
self.format_date_center_bold = workbook.add_format( self.format_date_center_bold = workbook.add_format(
{'align': 'center', 'bold': True, 'num_format': date_format}) {"align": "center", "bold": True, "num_format": date_format}
)
self.format_date_right_bold = workbook.add_format( self.format_date_right_bold = workbook.add_format(
{'align': 'right', 'bold': True, 'num_format': date_format}) {"align": "right", "bold": True, "num_format": date_format}
)
# formats for worksheet table column headers # formats for worksheet table column headers
self.format_theader_yellow_left = workbook.add_format(theader_yellow) self.format_theader_yellow_left = workbook.add_format(theader_yellow)
self.format_theader_yellow_center = workbook.add_format( self.format_theader_yellow_center = workbook.add_format(
dict(theader_yellow, align='center')) dict(theader_yellow, align="center")
)
self.format_theader_yellow_right = workbook.add_format( self.format_theader_yellow_right = workbook.add_format(
dict(theader_yellow, align='right')) dict(theader_yellow, align="right")
)
self.format_theader_yellow_amount_left = workbook.add_format( self.format_theader_yellow_amount_left = workbook.add_format(
dict(theader_yellow, num_format=num_format, align='left')) dict(theader_yellow, num_format=num_format, align="left")
)
self.format_theader_yellow_amount_center = workbook.add_format( self.format_theader_yellow_amount_center = workbook.add_format(
dict(theader_yellow, num_format=num_format, align='center')) dict(theader_yellow, num_format=num_format, align="center")
)
self.format_theader_yellow_amount_right = workbook.add_format( self.format_theader_yellow_amount_right = workbook.add_format(
dict(theader_yellow, num_format=num_format, align='right')) dict(theader_yellow, num_format=num_format, align="right")
)
self.format_theader_yellow_amount_conditional_left = workbook.\ self.format_theader_yellow_amount_conditional_left = workbook.add_format(
add_format(dict(theader_yellow, num_format=num_format_conditional, dict(theader_yellow, num_format=num_format_conditional, align="left")
align='left')) )
self.format_theader_yellow_amount_conditional_center = workbook.\ self.format_theader_yellow_amount_conditional_center = workbook.add_format(
add_format(dict(theader_yellow, num_format=num_format_conditional, dict(theader_yellow, num_format=num_format_conditional, align="center")
align='center')) )
self.format_theader_yellow_amount_conditional_right = workbook.\ self.format_theader_yellow_amount_conditional_right = workbook.add_format(
add_format(dict(theader_yellow, num_format=num_format_conditional, dict(theader_yellow, num_format=num_format_conditional, align="right")
align='right')) )
self.format_theader_yellow_percent_left = workbook.add_format( self.format_theader_yellow_percent_left = workbook.add_format(
dict(theader_yellow, num_format=pct_format, align='left')) dict(theader_yellow, num_format=pct_format, align="left")
)
self.format_theader_yellow_percent_center = workbook.add_format( self.format_theader_yellow_percent_center = workbook.add_format(
dict(theader_yellow, num_format=pct_format, align='center')) dict(theader_yellow, num_format=pct_format, align="center")
)
self.format_theader_yellow_percent_right = workbook.add_format( self.format_theader_yellow_percent_right = workbook.add_format(
dict(theader_yellow, num_format=pct_format, align='right')) dict(theader_yellow, num_format=pct_format, align="right")
self.format_theader_yellow_percent_conditional_left = workbook.\ )
add_format(dict(theader_yellow, num_format=pct_format_conditional, self.format_theader_yellow_percent_conditional_left = workbook.add_format(
align='left')) dict(theader_yellow, num_format=pct_format_conditional, align="left")
self.format_theader_yellow_percent_conditional_center = workbook.\ )
add_format(dict(theader_yellow, num_format=pct_format_conditional, self.format_theader_yellow_percent_conditional_center = workbook.add_format(
align='center')) dict(theader_yellow, num_format=pct_format_conditional, align="center")
self.format_theader_yellow_percent_conditional_right = workbook.\ )
add_format(dict(theader_yellow, num_format=pct_format_conditional, self.format_theader_yellow_percent_conditional_right = workbook.add_format(
align='right')) dict(theader_yellow, num_format=pct_format_conditional, align="right")
)
self.format_theader_yellow_integer_left = workbook.add_format( self.format_theader_yellow_integer_left = workbook.add_format(
dict(theader_yellow, num_format=int_format, align='left')) dict(theader_yellow, num_format=int_format, align="left")
)
self.format_theader_yellow_integer_center = workbook.add_format( self.format_theader_yellow_integer_center = workbook.add_format(
dict(theader_yellow, num_format=int_format, align='center')) dict(theader_yellow, num_format=int_format, align="center")
)
self.format_theader_yellow_integer_right = workbook.add_format( self.format_theader_yellow_integer_right = workbook.add_format(
dict(theader_yellow, num_format=int_format, align='right')) dict(theader_yellow, num_format=int_format, align="right")
self.format_theader_yellow_integer_conditional_left = workbook.\ )
add_format(dict(theader_yellow, num_format=int_format_conditional, self.format_theader_yellow_integer_conditional_left = workbook.add_format(
align='left')) dict(theader_yellow, num_format=int_format_conditional, align="left")
self.format_theader_yellow_integer_conditional_center = workbook.\ )
add_format(dict(theader_yellow, num_format=int_format_conditional, self.format_theader_yellow_integer_conditional_center = workbook.add_format(
align='center')) dict(theader_yellow, num_format=int_format_conditional, align="center")
self.format_theader_yellow_integer_conditional_right = workbook.\ )
add_format(dict(theader_yellow, num_format=int_format_conditional, self.format_theader_yellow_integer_conditional_right = workbook.add_format(
align='right')) dict(theader_yellow, num_format=int_format_conditional, align="right")
)
self.format_theader_blue_left = workbook.add_format(theader_blue) self.format_theader_blue_left = workbook.add_format(theader_blue)
self.format_theader_blue_center = workbook.add_format( self.format_theader_blue_center = workbook.add_format(
dict(theader_blue, align='center')) dict(theader_blue, align="center")
)
self.format_theader_blue_right = workbook.add_format( self.format_theader_blue_right = workbook.add_format(
dict(theader_blue, align='right')) dict(theader_blue, align="right")
)
self.format_theader_blue_amount_left = workbook.add_format( self.format_theader_blue_amount_left = workbook.add_format(
dict(theader_blue, num_format=num_format, align='left')) dict(theader_blue, num_format=num_format, align="left")
)
self.format_theader_blue_amount_center = workbook.add_format( self.format_theader_blue_amount_center = workbook.add_format(
dict(theader_blue, num_format=num_format, align='center')) dict(theader_blue, num_format=num_format, align="center")
)
self.format_theader_blue_amount_right = workbook.add_format( self.format_theader_blue_amount_right = workbook.add_format(
dict(theader_blue, num_format=num_format, align='right')) dict(theader_blue, num_format=num_format, align="right")
self.format_theader_blue_amount_conditional_left = workbook.\ )
add_format(dict(theader_blue, num_format=num_format_conditional, self.format_theader_blue_amount_conditional_left = workbook.add_format(
align='left')) dict(theader_blue, num_format=num_format_conditional, align="left")
self.format_theader_blue_amount_conditional_center = workbook.\ )
add_format(dict(theader_blue, num_format=num_format_conditional, self.format_theader_blue_amount_conditional_center = workbook.add_format(
align='center')) dict(theader_blue, num_format=num_format_conditional, align="center")
self.format_theader_blue_amount_conditional_right = workbook.\ )
add_format(dict(theader_blue, num_format=num_format_conditional, self.format_theader_blue_amount_conditional_right = workbook.add_format(
align='right')) dict(theader_blue, num_format=num_format_conditional, align="right")
)
self.format_theader_blue_percent_left = workbook.add_format( self.format_theader_blue_percent_left = workbook.add_format(
dict(theader_blue, num_format=pct_format, align='left')) dict(theader_blue, num_format=pct_format, align="left")
)
self.format_theader_blue_percent_center = workbook.add_format( self.format_theader_blue_percent_center = workbook.add_format(
dict(theader_blue, num_format=pct_format, align='center')) dict(theader_blue, num_format=pct_format, align="center")
)
self.format_theader_blue_percent_right = workbook.add_format( self.format_theader_blue_percent_right = workbook.add_format(
dict(theader_blue, num_format=pct_format, align='right')) dict(theader_blue, num_format=pct_format, align="right")
self.format_theader_blue_percent_conditional_left = workbook.\ )
add_format(dict(theader_blue, num_format=pct_format_conditional, self.format_theader_blue_percent_conditional_left = workbook.add_format(
align='left')) dict(theader_blue, num_format=pct_format_conditional, align="left")
self.format_theader_blue_percent_conditional_center = workbook.\ )
add_format(dict(theader_blue, num_format=pct_format_conditional, self.format_theader_blue_percent_conditional_center = workbook.add_format(
align='center')) dict(theader_blue, num_format=pct_format_conditional, align="center")
self.format_theader_blue_percent_conditional_right = workbook.\ )
add_format(dict(theader_blue, num_format=pct_format_conditional, self.format_theader_blue_percent_conditional_right = workbook.add_format(
align='right')) dict(theader_blue, num_format=pct_format_conditional, align="right")
)
self.format_theader_blue_integer_left = workbook.add_format( self.format_theader_blue_integer_left = workbook.add_format(
dict(theader_blue, num_format=int_format, align='left')) dict(theader_blue, num_format=int_format, align="left")
)
self.format_theader_blue_integer_center = workbook.add_format( self.format_theader_blue_integer_center = workbook.add_format(
dict(theader_blue, num_format=int_format, align='center')) dict(theader_blue, num_format=int_format, align="center")
)
self.format_theader_blue_integer_right = workbook.add_format( self.format_theader_blue_integer_right = workbook.add_format(
dict(theader_blue, num_format=int_format, align='right')) dict(theader_blue, num_format=int_format, align="right")
self.format_theader_blue_integer_conditional_left = workbook.\ )
add_format(dict(theader_blue, num_format=int_format_conditional, self.format_theader_blue_integer_conditional_left = workbook.add_format(
align='left')) dict(theader_blue, num_format=int_format_conditional, align="left")
self.format_theader_blue_integer_conditional_center = workbook.\ )
add_format(dict(theader_blue, num_format=int_format_conditional, self.format_theader_blue_integer_conditional_center = workbook.add_format(
align='center')) dict(theader_blue, num_format=int_format_conditional, align="center")
self.format_theader_blue_integer_conditional_right = workbook.\ )
add_format(dict(theader_blue, num_format=int_format_conditional, self.format_theader_blue_integer_conditional_right = workbook.add_format(
align='right')) dict(theader_blue, num_format=int_format_conditional, align="right")
)
# formats for worksheet table cells # formats for worksheet table cells
self.format_tcell_left = workbook.add_format( self.format_tcell_left = workbook.add_format(dict(border, align="left"))
dict(border, align='left')) self.format_tcell_center = workbook.add_format(dict(border, align="center"))
self.format_tcell_center = workbook.add_format( self.format_tcell_right = workbook.add_format(dict(border, align="right"))
dict(border, align='center'))
self.format_tcell_right = workbook.add_format(
dict(border, align='right'))
self.format_tcell_amount_left = workbook.add_format( self.format_tcell_amount_left = workbook.add_format(
dict(border, num_format=num_format, align='left')) dict(border, num_format=num_format, align="left")
)
self.format_tcell_amount_center = workbook.add_format( self.format_tcell_amount_center = workbook.add_format(
dict(border, num_format=num_format, align='center')) dict(border, num_format=num_format, align="center")
)
self.format_tcell_amount_right = workbook.add_format( self.format_tcell_amount_right = workbook.add_format(
dict(border, num_format=num_format, align='right')) dict(border, num_format=num_format, align="right")
)
self.format_tcell_amount_conditional_left = workbook.add_format( self.format_tcell_amount_conditional_left = workbook.add_format(
dict(border, num_format=num_format_conditional, align='left')) dict(border, num_format=num_format_conditional, align="left")
)
self.format_tcell_amount_conditional_center = workbook.add_format( self.format_tcell_amount_conditional_center = workbook.add_format(
dict(border, num_format=num_format_conditional, align='center')) dict(border, num_format=num_format_conditional, align="center")
)
self.format_tcell_amount_conditional_right = workbook.add_format( self.format_tcell_amount_conditional_right = workbook.add_format(
dict(border, num_format=num_format_conditional, align='right')) dict(border, num_format=num_format_conditional, align="right")
)
self.format_tcell_percent_left = workbook.add_format( self.format_tcell_percent_left = workbook.add_format(
dict(border, num_format=pct_format, align='left')) dict(border, num_format=pct_format, align="left")
)
self.format_tcell_percent_center = workbook.add_format( self.format_tcell_percent_center = workbook.add_format(
dict(border, num_format=pct_format, align='center')) dict(border, num_format=pct_format, align="center")
)
self.format_tcell_percent_right = workbook.add_format( self.format_tcell_percent_right = workbook.add_format(
dict(border, num_format=pct_format, align='right')) dict(border, num_format=pct_format, align="right")
)
self.format_tcell_percent_conditional_left = workbook.add_format( self.format_tcell_percent_conditional_left = workbook.add_format(
dict(border, num_format=pct_format_conditional, align='left')) dict(border, num_format=pct_format_conditional, align="left")
)
self.format_tcell_percent_conditional_center = workbook.add_format( self.format_tcell_percent_conditional_center = workbook.add_format(
dict(border, num_format=pct_format_conditional, align='center')) dict(border, num_format=pct_format_conditional, align="center")
)
self.format_tcell_percent_conditional_right = workbook.add_format( self.format_tcell_percent_conditional_right = workbook.add_format(
dict(border, num_format=pct_format_conditional, align='right')) dict(border, num_format=pct_format_conditional, align="right")
)
self.format_tcell_integer_left = workbook.add_format( self.format_tcell_integer_left = workbook.add_format(
dict(border, num_format=int_format, align='left')) dict(border, num_format=int_format, align="left")
)
self.format_tcell_integer_center = workbook.add_format( self.format_tcell_integer_center = workbook.add_format(
dict(border, num_format=int_format, align='center')) dict(border, num_format=int_format, align="center")
)
self.format_tcell_integer_right = workbook.add_format( self.format_tcell_integer_right = workbook.add_format(
dict(border, num_format=int_format, align='right')) dict(border, num_format=int_format, align="right")
)
self.format_tcell_integer_conditional_left = workbook.add_format( self.format_tcell_integer_conditional_left = workbook.add_format(
dict(border, num_format=int_format_conditional, align='left')) dict(border, num_format=int_format_conditional, align="left")
)
self.format_tcell_integer_conditional_center = workbook.add_format( self.format_tcell_integer_conditional_center = workbook.add_format(
dict(border, num_format=int_format_conditional, align='center')) dict(border, num_format=int_format_conditional, align="center")
)
self.format_tcell_integer_conditional_right = workbook.add_format( self.format_tcell_integer_conditional_right = workbook.add_format(
dict(border, num_format=int_format_conditional, align='right')) dict(border, num_format=int_format_conditional, align="right")
)
self.format_tcell_date_left = workbook.add_format( self.format_tcell_date_left = workbook.add_format(
dict(border, num_format=date_format, align='left')) dict(border, num_format=date_format, align="left")
)
self.format_tcell_date_center = workbook.add_format( self.format_tcell_date_center = workbook.add_format(
dict(border, num_format=date_format, align='center')) dict(border, num_format=date_format, align="center")
)
self.format_tcell_date_right = workbook.add_format( self.format_tcell_date_right = workbook.add_format(
dict(border, num_format=date_format, align='right')) dict(border, num_format=date_format, align="right")
)
self.format_tcell_left_bold = workbook.add_format( self.format_tcell_left_bold = workbook.add_format(
dict(border, align='left', bold=True)) dict(border, align="left", bold=True)
)
self.format_tcell_center_bold = workbook.add_format( self.format_tcell_center_bold = workbook.add_format(
dict(border, align='center', bold=True)) dict(border, align="center", bold=True)
)
self.format_tcell_right_bold = workbook.add_format( self.format_tcell_right_bold = workbook.add_format(
dict(border, align='right', bold=True)) dict(border, align="right", bold=True)
)
self.format_tcell_amount_left_bold = workbook.add_format( self.format_tcell_amount_left_bold = workbook.add_format(
dict(border, num_format=num_format, align='left', bold=True)) dict(border, num_format=num_format, align="left", bold=True)
)
self.format_tcell_amount_center_bold = workbook.add_format( self.format_tcell_amount_center_bold = workbook.add_format(
dict(border, num_format=num_format, align='center', bold=True)) dict(border, num_format=num_format, align="center", bold=True)
)
self.format_tcell_amount_right_bold = workbook.add_format( self.format_tcell_amount_right_bold = workbook.add_format(
dict(border, num_format=num_format, align='right', bold=True)) dict(border, num_format=num_format, align="right", bold=True)
self.format_tcell_amount_conditional_left_bold = workbook.\ )
add_format(dict(border, num_format=num_format_conditional, self.format_tcell_amount_conditional_left_bold = workbook.add_format(
align='left', bold=True)) dict(border, num_format=num_format_conditional, align="left", bold=True)
self.format_tcell_amount_conditional_center_bold = workbook.\ )
add_format(dict(border, num_format=num_format_conditional, self.format_tcell_amount_conditional_center_bold = workbook.add_format(
align='center', bold=True)) dict(border, num_format=num_format_conditional, align="center", bold=True)
self.format_tcell_amount_conditional_right_bold = workbook.\ )
add_format(dict(border, num_format=num_format_conditional, self.format_tcell_amount_conditional_right_bold = workbook.add_format(
align='right', bold=True)) dict(border, num_format=num_format_conditional, align="right", bold=True)
)
self.format_tcell_percent_left_bold = workbook.add_format( self.format_tcell_percent_left_bold = workbook.add_format(
dict(border, num_format=pct_format, align='left', bold=True)) dict(border, num_format=pct_format, align="left", bold=True)
)
self.format_tcell_percent_center_bold = workbook.add_format( self.format_tcell_percent_center_bold = workbook.add_format(
dict(border, num_format=pct_format, align='center', bold=True)) dict(border, num_format=pct_format, align="center", bold=True)
)
self.format_tcell_percent_right_bold = workbook.add_format( self.format_tcell_percent_right_bold = workbook.add_format(
dict(border, num_format=pct_format, align='right', bold=True)) dict(border, num_format=pct_format, align="right", bold=True)
self.format_tcell_percent_conditional_left_bold = workbook.\ )
add_format(dict(border, num_format=pct_format_conditional, self.format_tcell_percent_conditional_left_bold = workbook.add_format(
align='left', bold=True)) dict(border, num_format=pct_format_conditional, align="left", bold=True)
self.format_tcell_percent_conditional_center_bold = workbook.\ )
add_format(dict(border, num_format=pct_format_conditional, self.format_tcell_percent_conditional_center_bold = workbook.add_format(
align='center', bold=True)) dict(border, num_format=pct_format_conditional, align="center", bold=True)
self.format_tcell_percent_conditional_right_bold = workbook.\ )
add_format(dict(border, num_format=pct_format_conditional, self.format_tcell_percent_conditional_right_bold = workbook.add_format(
align='right', bold=True)) dict(border, num_format=pct_format_conditional, align="right", bold=True)
)
self.format_tcell_integer_left_bold = workbook.add_format( self.format_tcell_integer_left_bold = workbook.add_format(
dict(border, num_format=int_format, align='left', bold=True)) dict(border, num_format=int_format, align="left", bold=True)
)
self.format_tcell_integer_center_bold = workbook.add_format( self.format_tcell_integer_center_bold = workbook.add_format(
dict(border, num_format=int_format, align='center', bold=True)) dict(border, num_format=int_format, align="center", bold=True)
)
self.format_tcell_integer_right_bold = workbook.add_format( self.format_tcell_integer_right_bold = workbook.add_format(
dict(border, num_format=int_format, align='right', bold=True)) dict(border, num_format=int_format, align="right", bold=True)
self.format_tcell_integer_conditional_left_bold = workbook.\ )
add_format(dict(border, num_format=int_format_conditional, self.format_tcell_integer_conditional_left_bold = workbook.add_format(
align='left', bold=True)) dict(border, num_format=int_format_conditional, align="left", bold=True)
self.format_tcell_integer_conditional_center_bold = workbook.\ )
add_format(dict(border, num_format=int_format_conditional, self.format_tcell_integer_conditional_center_bold = workbook.add_format(
align='center', bold=True)) dict(border, num_format=int_format_conditional, align="center", bold=True)
self.format_tcell_integer_conditional_right_bold = workbook.\ )
add_format(dict(border, num_format=int_format_conditional, self.format_tcell_integer_conditional_right_bold = workbook.add_format(
align='right', bold=True)) dict(border, num_format=int_format_conditional, align="right", bold=True)
)
self.format_tcell_date_left_bold = workbook.add_format( self.format_tcell_date_left_bold = workbook.add_format(
dict(border, num_format=date_format, align='left', bold=True)) dict(border, num_format=date_format, align="left", bold=True)
)
self.format_tcell_date_center_bold = workbook.add_format( self.format_tcell_date_center_bold = workbook.add_format(
dict(border, num_format=date_format, align='center', bold=True)) dict(border, num_format=date_format, align="center", bold=True)
)
self.format_tcell_date_right_bold = workbook.add_format( self.format_tcell_date_right_bold = workbook.add_format(
dict(border, num_format=date_format, align='right', bold=True)) dict(border, num_format=date_format, align="right", bold=True)
)
def _set_column_width(self, ws, ws_params): def _set_column_width(self, ws, ws_params):
""" """
Set width for all columns included in the 'wanted_list'. Set width for all columns included in the 'wanted_list'.
""" """
col_specs = ws_params.get('col_specs') col_specs = ws_params.get("col_specs")
wl = ws_params.get('wanted_list') or [] wl = ws_params.get("wanted_list") or []
for pos, col in enumerate(wl): for pos, col in enumerate(wl):
if col not in col_specs: if col not in col_specs:
raise UserError(_( raise UserError(
"Programming Error:\n\n" _(
"The '%s' column is not defined in the worksheet " "Programming Error:\n\n"
"column specifications.") % col) "The '%s' column is not defined in the worksheet "
ws.set_column(pos, pos, col_specs[col]['width']) "column specifications."
)
% col
)
ws.set_column(pos, pos, col_specs[col]["width"])
def _write_ws_title(self, ws, row_pos, ws_params, merge_range=False): def _write_ws_title(self, ws, row_pos, ws_params, merge_range=False):
""" """
@ -447,69 +542,82 @@ class ReportXlsxAbstract(models.AbstractModel):
troughout all worksheets. troughout all worksheets.
Requires 'title' keyword in ws_params. Requires 'title' keyword in ws_params.
""" """
title = ws_params.get('title') title = ws_params.get("title")
if not title: if not title:
raise UserError(_( raise UserError(
"Programming Error:\n\n" _(
"The 'title' parameter is mandatory " "Programming Error:\n\n"
"when calling the '_write_ws_title' method.")) "The 'title' parameter is mandatory "
"when calling the '_write_ws_title' method."
)
)
if merge_range: if merge_range:
wl = ws_params.get('wanted_list') wl = ws_params.get("wanted_list")
if wl and len(wl) > 1: if wl and len(wl) > 1:
ws.merge_range( ws.merge_range(
row_pos, 0, row_pos, len(wl) - 1, row_pos, 0, row_pos, len(wl) - 1, title, self.format_ws_title
title, self.format_ws_title) )
else: else:
ws.write_string(row_pos, 0, title, self.format_ws_title) ws.write_string(row_pos, 0, title, self.format_ws_title)
return row_pos + 2 return row_pos + 2
def _write_line(self, ws, row_pos, ws_params, col_specs_section=None, def _write_line(
render_space=None, default_format=None): self,
ws,
row_pos,
ws_params,
col_specs_section=None,
render_space=None,
default_format=None,
):
""" """
Write a line with all columns included in the 'wanted_list'. Write a line with all columns included in the 'wanted_list'.
Use the entry defined by the col_specs_section. Use the entry defined by the col_specs_section.
An empty cell will be written if no col_specs_section entry An empty cell will be written if no col_specs_section entry
for a column. for a column.
""" """
col_specs = ws_params.get('col_specs') col_specs = ws_params.get("col_specs")
wl = ws_params.get('wanted_list') or [] wl = ws_params.get("wanted_list") or []
pos = 0 pos = 0
for col in wl: for col in wl:
if col not in col_specs: if col not in col_specs:
raise UserError(_( raise UserError(
"Programming Error:\n\n" _(
"The '%s' column is not defined the worksheet " "Programming Error:\n\n"
"column specifications.") % col) "The '%s' column is not defined the worksheet "
colspan = col_specs[col].get('colspan') or 1 "column specifications."
)
% col
)
colspan = col_specs[col].get("colspan") or 1
cell_spec = col_specs[col].get(col_specs_section) or {} cell_spec = col_specs[col].get(col_specs_section) or {}
if not cell_spec: if not cell_spec:
cell_value = None cell_value = None
cell_type = 'blank' cell_type = "blank"
cell_format = default_format cell_format = default_format
else: else:
cell_value = cell_spec.get('value') cell_value = cell_spec.get("value")
if isinstance(cell_value, CodeType): if isinstance(cell_value, CodeType):
cell_value = self._eval(cell_value, render_space) cell_value = self._eval(cell_value, render_space)
cell_type = cell_spec.get('type') cell_type = cell_spec.get("type")
cell_format = cell_spec.get('format') or default_format cell_format = cell_spec.get("format") or default_format
if not cell_type: if not cell_type:
# test bool first since isinstance(val, int) returns # test bool first since isinstance(val, int) returns
# True when type(val) is bool # True when type(val) is bool
if isinstance(cell_value, bool): if isinstance(cell_value, bool):
cell_type = 'boolean' cell_type = "boolean"
elif isinstance(cell_value, str): elif isinstance(cell_value, str):
cell_type = 'string' cell_type = "string"
elif isinstance(cell_value, (int, float)): elif isinstance(cell_value, (int, float)):
cell_type = 'number' cell_type = "number"
elif isinstance(cell_value, datetime): elif isinstance(cell_value, datetime):
cell_type = 'datetime' cell_type = "datetime"
elif isinstance(cell_value, date): elif isinstance(cell_value, date):
cell_value = datetime.combine( cell_value = datetime.combine(cell_value, datetime.min.time())
cell_value, datetime.min.time()) cell_type = "datetime"
cell_type = 'datetime'
else: else:
if not cell_value: if not cell_value:
cell_type = 'blank' cell_type = "blank"
else: else:
msg = _( msg = _(
"%s, _write_line : programming error " "%s, _write_line : programming error "
@ -519,7 +627,7 @@ class ReportXlsxAbstract(models.AbstractModel):
if cell_value: if cell_value:
msg += _(", cellvalue %s") % cell_value msg += _(", cellvalue %s") % cell_value
raise UserError(msg) raise UserError(msg)
colspan = cell_spec.get('colspan') or colspan colspan = cell_spec.get("colspan") or colspan
args_pos = [row_pos, pos] args_pos = [row_pos, pos]
args_data = [cell_value] args_data = [cell_value]
if cell_format: if cell_format:
@ -531,7 +639,7 @@ class ReportXlsxAbstract(models.AbstractModel):
args = args_pos + args_data args = args_pos + args_data
ws.merge_range(*args) ws.merge_range(*args)
else: else:
ws_method = getattr(ws, 'write_%s' % cell_type) ws_method = getattr(ws, "write_%s" % cell_type)
args = args_pos + args_data args = args_pos + args_data
ws_method(*args) ws_method(*args)
pos += colspan pos += colspan
@ -540,14 +648,14 @@ class ReportXlsxAbstract(models.AbstractModel):
@staticmethod @staticmethod
def _render(code): def _render(code):
return compile(code, '<string>', 'eval') return compile(code, "<string>", "eval")
@staticmethod @staticmethod
def _eval(val, render_space): def _eval(val, render_space):
if not render_space: if not render_space:
render_space = {} render_space = {}
if 'datetime' not in render_space: if "datetime" not in render_space:
render_space['datetime'] = datetime render_space["datetime"] = datetime
# the use of eval is not a security thread as long as the # the use of eval is not a security thread as long as the
# col_specs template is defined in a python module # col_specs template is defined in a python module
return eval(val, render_space) # pylint: disable=W0123,W8112 return eval(val, render_space) # pylint: disable=W0123,W8112

108
report_xlsx_helper/report/test_partner_report_xlsx.py
View File

@ -9,66 +9,45 @@ from odoo import models
# to the tests folder (requires dynamic update Odoo registry when # to the tests folder (requires dynamic update Odoo registry when
# running unit tests. # running unit tests.
class TestPartnerXlsx(models.AbstractModel): class TestPartnerXlsx(models.AbstractModel):
_name = 'report.report_xlsx_helper.test_partner_xlsx' _name = "report.report_xlsx_helper.test_partner_xlsx"
_inherit = 'report.report_xlsx.abstract' _inherit = "report.report_xlsx.abstract"
def _get_ws_params(self, wb, data, partners): def _get_ws_params(self, wb, data, partners):
partner_template = { partner_template = {
'name': { "name": {
'header': { "header": {"value": "Name"},
'value': 'Name', "data": {"value": self._render("partner.name")},
}, "width": 20,
'data': {
'value': self._render("partner.name"),
},
'width': 20,
}, },
'number_of_contacts': { "number_of_contacts": {
'header': { "header": {"value": "# Contacts"},
'value': '# Contacts', "data": {"value": self._render("len(partner.child_ids)")},
}, "width": 10,
'data': {
'value': self._render("len(partner.child_ids)"),
},
'width': 10,
}, },
'is_customer': { "is_customer": {
'header': { "header": {"value": "Customer"},
'value': 'Customer', "data": {"value": self._render("partner.customer")},
}, "width": 10,
'data': {
'value': self._render("partner.customer"),
},
'width': 10,
}, },
'is_customer_formula': { "is_customer_formula": {
'header': { "header": {"value": "Customer Y/N ?"},
'value': 'Customer Y/N ?', "data": {"type": "formula", "value": self._render("customer_formula")},
}, "width": 14,
'data': {
'type': 'formula',
'value': self._render("customer_formula"),
},
'width': 14,
}, },
'date': { "date": {
'header': { "header": {"value": "Date"},
'value': 'Date', "data": {"value": self._render("partner.date")},
}, "width": 13,
'data': {
'value': self._render("partner.date"),
},
'width': 13,
}, },
} }
ws_params = { ws_params = {
'ws_name': 'Partners', "ws_name": "Partners",
'generate_ws_method': '_partner_report', "generate_ws_method": "_partner_report",
'title': 'Partners', "title": "Partners",
'wanted_list': [k for k in partner_template], "wanted_list": [k for k in partner_template],
'col_specs': partner_template, "col_specs": partner_template,
} }
return [ws_params] return [ws_params]
@ -77,30 +56,33 @@ class TestPartnerXlsx(models.AbstractModel):
ws.set_portrait() ws.set_portrait()
ws.fit_to_pages(1, 0) ws.fit_to_pages(1, 0)
ws.set_header(self.xls_headers['standard']) ws.set_header(self.xls_headers["standard"])
ws.set_footer(self.xls_footers['standard']) ws.set_footer(self.xls_footers["standard"])
self._set_column_width(ws, ws_params) self._set_column_width(ws, ws_params)
row_pos = 0 row_pos = 0
row_pos = self._write_ws_title(ws, row_pos, ws_params) row_pos = self._write_ws_title(ws, row_pos, ws_params)
row_pos = self._write_line( row_pos = self._write_line(
ws, row_pos, ws_params, col_specs_section='header', ws,
default_format=self.format_theader_yellow_left) row_pos,
ws_params,
col_specs_section="header",
default_format=self.format_theader_yellow_left,
)
ws.freeze_panes(row_pos, 0) ws.freeze_panes(row_pos, 0)
wl = ws_params['wanted_list'] wl = ws_params["wanted_list"]
for partner in partners: for partner in partners:
is_customer_pos = 'is_customer' in wl and \ is_customer_pos = "is_customer" in wl and wl.index("is_customer")
wl.index('is_customer') is_customer_cell = self._rowcol_to_cell(row_pos, is_customer_pos)
is_customer_cell = self._rowcol_to_cell(
row_pos, is_customer_pos)
customer_formula = 'IF({},"Y", "N")'.format(is_customer_cell) customer_formula = 'IF({},"Y", "N")'.format(is_customer_cell)
row_pos = self._write_line( row_pos = self._write_line(
ws, row_pos, ws_params, col_specs_section='data', ws,
render_space={ row_pos,
'partner': partner, ws_params,
'customer_formula': customer_formula, col_specs_section="data",
}, render_space={"partner": partner, "customer_formula": customer_formula},
default_format=self.format_tcell_left) default_format=self.format_tcell_left,
)

15
report_xlsx_helper/tests/test_report_xlsx_helper.py
View File

@ -7,22 +7,21 @@ from odoo.tests.common import TransactionCase
class TestReportXlsxHelper(TransactionCase): class TestReportXlsxHelper(TransactionCase):
def setUp(self): def setUp(self):
super(TestReportXlsxHelper, self).setUp() super(TestReportXlsxHelper, self).setUp()
today = date.today() today = date.today()
p1 = self.env.ref('base.res_partner_1') p1 = self.env.ref("base.res_partner_1")
p2 = self.env.ref('base.res_partner_2') p2 = self.env.ref("base.res_partner_2")
p1.date = today p1.date = today
p2.date = today p2.date = today
self.partners = p1 + p2 self.partners = p1 + p2
ctx = { ctx = {
'report_name': 'report_xlsx_helper.test_partner_xlsx', "report_name": "report_xlsx_helper.test_partner_xlsx",
'active_model': 'res.partner', "active_model": "res.partner",
'active_ids': self.partners.ids, "active_ids": self.partners.ids,
} }
self.report = self.env['ir.actions.report'].with_context(ctx) self.report = self.env["ir.actions.report"].with_context(ctx)
def test_report_xlsx_helper(self): def test_report_xlsx_helper(self):
report_xls = self.report.render_xlsx(None, None) report_xls = self.report.render_xlsx(None, None)
self.assertEqual(report_xls[1], 'xlsx') self.assertEqual(report_xls[1], "xlsx")