412 lines
13 KiB
Python
412 lines
13 KiB
Python
|
|
import html
|
|
import io
|
|
import math
|
|
import pathlib
|
|
import string
|
|
|
|
import jinja2
|
|
import odfdo
|
|
# from odfdo import Cell, Document, Row, Style, Table
|
|
from odfdo.element import Element
|
|
from src import models
|
|
from src.contracts import service
|
|
from weasyprint import HTML
|
|
|
|
|
|
def generate_html_contract(
|
|
contract: models.Contract,
|
|
cheques: list[dict],
|
|
occasionals: list[dict],
|
|
reccurents: list[dict],
|
|
recurrent_price: float | None = None,
|
|
total_price: float | None = None
|
|
):
|
|
template_dir = pathlib.Path("./src/contracts/templates").resolve()
|
|
template_loader = jinja2.FileSystemLoader(searchpath=template_dir)
|
|
template_env = jinja2.Environment(
|
|
loader=template_loader, autoescape=jinja2.select_autoescape(["html", "xml"]))
|
|
template_file = "layout.html"
|
|
template = template_env.get_template(template_file)
|
|
output_text = template.render(
|
|
contract_name=contract.form.name,
|
|
contract_type=contract.form.productor.type,
|
|
contract_season=contract.form.season,
|
|
referer_name=contract.form.referer.name,
|
|
referer_email=contract.form.referer.email,
|
|
productor_name=contract.form.productor.name,
|
|
productor_address=contract.form.productor.address,
|
|
payment_methods_map={
|
|
"cheque": "Ordre du chèque",
|
|
"transfer": "virements"},
|
|
productor_payment_methods=contract.form.productor.payment_methods,
|
|
member_name=f'{
|
|
html.escape(
|
|
contract.firstname)} {
|
|
html.escape(
|
|
contract.lastname)}',
|
|
member_email=html.escape(
|
|
contract.email),
|
|
member_phone=html.escape(
|
|
contract.phone),
|
|
contract_start_date=contract.form.start,
|
|
contract_end_date=contract.form.end,
|
|
occasionals=occasionals,
|
|
recurrents=reccurents,
|
|
recurrent_price=recurrent_price,
|
|
total_price=total_price,
|
|
contract_payment_method={
|
|
"cheque": "chèque",
|
|
"transfer": "virements"}[
|
|
contract.payment_method],
|
|
cheques=cheques)
|
|
|
|
return HTML(
|
|
string=output_text,
|
|
base_url=template_dir,
|
|
).write_pdf()
|
|
|
|
|
|
def flatten(xss):
|
|
return [x for xs in xss for x in xs]
|
|
|
|
|
|
def create_column_style_width(size: str) -> odfdo.Style:
|
|
"""Create a table columm style for a given width.
|
|
Paramenters:
|
|
size(str): size of the style (format <number><unit>) unit can be in, cm... see odfdo documentation.
|
|
Returns:
|
|
odfdo.Style with the correct column-width attribute.
|
|
"""
|
|
return odfdo.Element.from_tag(
|
|
'<style:style style:name="product-table.A" style:family="table-column">'
|
|
f'<style:table-column-properties style:column-width="{size}"/>'
|
|
'</style:style>'
|
|
)
|
|
|
|
|
|
def create_row_style_height(size: str) -> odfdo.Style:
|
|
"""Create a table height style for a given height.
|
|
Paramenters:
|
|
size(str): size of the style (format <number><unit>) unit can be in, cm... see odfdo documentation.
|
|
Returns:
|
|
odfdo.Style with the correct column-height attribute.
|
|
"""
|
|
return odfdo.Element.from_tag(
|
|
'<style:style style:name="product-table.A" style:family="table-row">'
|
|
f'<style:table-row-properties style:row-height="{size}"/>'
|
|
'</style:style>'
|
|
)
|
|
|
|
|
|
def create_cell_style(
|
|
name: str = "centered-cell",
|
|
font_size: str = '10pt',
|
|
bold: bool = False,
|
|
background_color: str = '#FFFFFF',
|
|
color: str = '#000000'
|
|
) -> odfdo.Style:
|
|
bold_attr = """
|
|
fo:font-weight="bold"
|
|
style:font-weight-asian="bold"
|
|
style:font-weight-complex="bold"
|
|
""" if bold else ''
|
|
return odfdo.Element.from_tag(
|
|
f"""<style:style style:name="{name}" style:family="table-cell">
|
|
<style:table-cell-properties
|
|
fo:border="0.75pt solid #000000"
|
|
style:vertical-align="middle"
|
|
fo:wrap-option="wrap"
|
|
fo:background-color="{background_color}"/>
|
|
<style:paragraph-properties fo:text-align="center"/>
|
|
<style:text-properties
|
|
{bold_attr}
|
|
fo:font-size="{font_size}"
|
|
fo:color="{color}"/>
|
|
</style:style>"""
|
|
)
|
|
|
|
|
|
def apply_cell_style(document: odfdo.Document, table: odfdo.Table):
|
|
header_style = document.insert_style(
|
|
create_cell_style(
|
|
name="header-cells",
|
|
bold=True,
|
|
font_size='12pt',
|
|
background_color="#3480eb",
|
|
color="#FFF"
|
|
)
|
|
)
|
|
|
|
body_style_even = document.insert_style(
|
|
create_cell_style(
|
|
name="body-style-even",
|
|
bold=False,
|
|
background_color="#e8eaed",
|
|
color="#000000"
|
|
)
|
|
)
|
|
|
|
body_style_odd = document.insert_style(
|
|
create_cell_style(
|
|
name="body-style-odd",
|
|
bold=False,
|
|
background_color="#FFFFFF",
|
|
color="#000000"
|
|
)
|
|
)
|
|
|
|
footer_style = document.insert_style(
|
|
create_cell_style(
|
|
name="footer-cells",
|
|
bold=True,
|
|
font_size='12pt',
|
|
)
|
|
)
|
|
|
|
for index, row in enumerate(table.get_rows()):
|
|
style = body_style_even
|
|
if index == 0 or index == 1:
|
|
style = header_style
|
|
elif index % 2 == 0:
|
|
style = body_style_even
|
|
elif index == len(table.get_rows()) - 1:
|
|
style = footer_style
|
|
else:
|
|
style = body_style_odd
|
|
for cell in row.get_cells():
|
|
cell.style = style
|
|
|
|
|
|
def apply_column_height_style(document: odfdo.Document, table: odfdo.Table):
|
|
header_style = document.insert_style(
|
|
style=create_row_style_height('1.60cm'), name='1.60cm', automatic=True
|
|
)
|
|
body_style = document.insert_style(
|
|
style=create_row_style_height('0.90cm'), name='0.90cm', automatic=True
|
|
)
|
|
for index, row in enumerate(table.get_rows()):
|
|
if index == 1:
|
|
row.style = header_style
|
|
else:
|
|
row.style = body_style
|
|
|
|
|
|
def apply_column_width_style(document: odfdo.Document, table: odfdo.Table, widths: list[str]):
|
|
"""Apply column width style to a table.
|
|
Parameters:
|
|
document(odfdo.Document): Document where the table is located.
|
|
table(odfdo.Table): Table to apply columns widths.
|
|
widths(list[str]): list of width in format <number><unit> unit ca be in, cm... see odfdo documentation.
|
|
"""
|
|
styles = []
|
|
for w in widths:
|
|
styles.append(document.insert_style(
|
|
style=create_column_style_width(w), name=w, automatic=True)
|
|
)
|
|
|
|
for position in range(table.width):
|
|
col = table.get_column(position)
|
|
col.style = styles[position]
|
|
table.set_column(position, col)
|
|
|
|
|
|
def generate_ods_letters(n: int):
|
|
letters = string.ascii_lowercase
|
|
result = []
|
|
for i in range(n):
|
|
if i > len(letters) - 1:
|
|
letter = f'{letters[int(i / len(letters)) - 1]}'
|
|
letter += f'{letters[i % len(letters)]}'
|
|
result.append(letter)
|
|
continue
|
|
letter = letters[i]
|
|
result.append(letters[i])
|
|
return result
|
|
|
|
|
|
def compute_contract_prices(contract: models.Contract) -> dict:
|
|
occasional_contract_products = list(
|
|
filter(
|
|
lambda contract_product: (
|
|
contract_product.product.type == models.ProductType.OCCASIONAL
|
|
),
|
|
contract.products
|
|
)
|
|
)
|
|
occasionals_dict = service.create_occasional_dict(
|
|
occasional_contract_products)
|
|
recurrents_dict = list(
|
|
map(
|
|
lambda x: {'product': x.product, 'quantity': x.quantity},
|
|
filter(
|
|
lambda contract_product: (
|
|
contract_product.product.type ==
|
|
models.ProductType.RECCURENT
|
|
),
|
|
contract.products
|
|
)
|
|
)
|
|
)
|
|
prices = service.generate_products_prices(
|
|
occasionals_dict,
|
|
recurrents_dict,
|
|
contract.form.shipments
|
|
)
|
|
return prices
|
|
|
|
|
|
def generate_recap(
|
|
contracts: list[models.Contract],
|
|
form: models.Form,
|
|
):
|
|
product_unit_map = {
|
|
'1': 'g',
|
|
'2': 'Kg',
|
|
'3': 'Piece'
|
|
}
|
|
recurrents = [
|
|
f'{pr.name}({product_unit_map[pr.unit]})'
|
|
for pr in form.productor.products
|
|
if pr.type == models.ProductType.RECCURENT
|
|
]
|
|
recurrents.sort()
|
|
occasionnals = [
|
|
f'{pr.name}({product_unit_map[pr.unit]})'
|
|
for pr in form.productor.products
|
|
if pr.type == models.ProductType.OCCASIONAL
|
|
]
|
|
occasionnals.sort()
|
|
shipments = form.shipments
|
|
occasionnals_header = [
|
|
occ for shipment in shipments for occ in occasionnals
|
|
]
|
|
|
|
info_header: list[str] = ['', 'Nom', 'Email']
|
|
cheque_header: list[str] = ['Cheque 1', 'Cheque 2', 'Cheque 3']
|
|
payment_header = (
|
|
cheque_header +
|
|
[f'Total {len(shipments)} livraisons + produits occasionnels']
|
|
)
|
|
prefix_header: list[str] = (
|
|
info_header +
|
|
payment_header
|
|
)
|
|
|
|
suffix_header: list[str] = [
|
|
'Total produits occasionnels',
|
|
'Remarques',
|
|
'Nom'
|
|
]
|
|
|
|
shipment_header = flatten([
|
|
[f'{shipment.name} - {shipment.date.strftime('%Y-%m-%d')}'] +
|
|
['' * len(occasionnals)] for shipment in shipments] +
|
|
[''] * len(suffix_header)
|
|
)
|
|
|
|
header: list[str] = (
|
|
prefix_header +
|
|
recurrents +
|
|
['Total produits récurrents'] +
|
|
occasionnals_header +
|
|
suffix_header
|
|
)
|
|
|
|
letters = generate_ods_letters(len(header))
|
|
payment_formula_letters = letters[
|
|
len(info_header):len(info_header) + len(payment_header)
|
|
]
|
|
recurent_formula_letters = letters[
|
|
len(info_header)+len(payment_formula_letters):
|
|
len(info_header)+len(payment_formula_letters)+len(recurrents) + 1
|
|
]
|
|
occasionnals_formula_letters = letters[
|
|
len(info_header)+len(payment_formula_letters)+len(recurent_formula_letters):
|
|
len(info_header)+len(payment_formula_letters) +
|
|
len(recurent_formula_letters)+len(occasionnals_header) + 1
|
|
]
|
|
print(payment_formula_letters)
|
|
print(recurent_formula_letters)
|
|
print(occasionnals_formula_letters)
|
|
|
|
footer = (
|
|
['', 'Total contrats', ''] +
|
|
[f'=SUM({letter}3:{letter}{2+len(contracts)})'
|
|
for letter in payment_formula_letters] +
|
|
[f'=SUM({letter}3:{letter}{2+len(contracts)})'
|
|
for letter in recurent_formula_letters] +
|
|
[f'=SUM({letter}3:{letter}{2+len(contracts)})'
|
|
for letter in occasionnals_formula_letters]
|
|
)
|
|
|
|
data = [
|
|
[''] * (len(prefix_header) + len(recurrents) + 1) + shipment_header,
|
|
header,
|
|
*[
|
|
[
|
|
f'{index + 1}',
|
|
f'{contract.firstname} {contract.lastname}',
|
|
f'{contract.email}',
|
|
*[float(contract.cheques[i].value) if len(
|
|
contract.cheques) > i else '' for i in range(3)],
|
|
compute_contract_prices(contract)['total'],
|
|
*[pr.quantity for pr in sorted(
|
|
contract.products, key=lambda x: x.product.name)
|
|
if pr.product.type == models.ProductType.RECCURENT],
|
|
compute_contract_prices(contract)['recurrent'],
|
|
*[pr.quantity for pr in sorted(
|
|
contract.products, key=lambda x: x.product.name)
|
|
if pr.product.type == models.ProductType.OCCASIONAL],
|
|
compute_contract_prices(contract)['occasionnal'],
|
|
'',
|
|
f'{contract.firstname} {contract.lastname}',
|
|
] for index, contract in enumerate(contracts)
|
|
],
|
|
footer
|
|
]
|
|
|
|
doc = odfdo.Document('spreadsheet')
|
|
sheet = doc.body.get_sheet(0)
|
|
sheet.name = 'Recap'
|
|
sheet.set_values(data)
|
|
|
|
index = len(prefix_header) + len(recurrents) + 1
|
|
for _ in enumerate(shipments):
|
|
startcol = index
|
|
endcol = index+len(occasionnals) - 1
|
|
sheet.set_span((startcol, 0, endcol, 0), merge=True)
|
|
index += len(occasionnals)
|
|
|
|
for row in sheet.get_rows():
|
|
for cell in row.get_cells():
|
|
if not cell.value or cell.get_attribute("office:value-type") == "float":
|
|
continue
|
|
if '=' in cell.value:
|
|
formula = cell.value
|
|
cell.clear()
|
|
cell.formula = formula
|
|
|
|
apply_column_width_style(
|
|
doc,
|
|
doc.body.get_table(0),
|
|
['2cm'] +
|
|
['4cm'] * 2 +
|
|
['2.40cm'] * (len(payment_header) - 1) +
|
|
['4cm'] * len(recurrents) +
|
|
['4cm'] +
|
|
['4cm'] * (len(occasionnals_header) + 1) +
|
|
['4cm', '8cm', '4cm']
|
|
)
|
|
apply_column_height_style(
|
|
doc,
|
|
doc.body.get_table(0),
|
|
)
|
|
apply_cell_style(doc, doc.body.get_table(0))
|
|
doc.body.append(sheet)
|
|
|
|
buffer = io.BytesIO()
|
|
doc.save(buffer)
|
|
# doc.save('test.ods')
|
|
return buffer.getvalue()
|