279 lines
11 KiB
Python
279 lines
11 KiB
Python
import mysql.connector
|
|
from docx import Document
|
|
from datetime import datetime
|
|
from docx.shared import Pt
|
|
from docx.oxml.ns import qn
|
|
from docx.enum.text import WD_ALIGN_PARAGRAPH, WD_BREAK
|
|
from docx.enum.table import WD_ALIGN_VERTICAL
|
|
from docx.oxml import OxmlElement
|
|
import os
|
|
from datetime import datetime, timedelta
|
|
from dotenv import load_dotenv
|
|
from dateutil.relativedelta import relativedelta
|
|
|
|
load_dotenv()
|
|
|
|
def fetch_tickets_from_database():
|
|
# Verbindung zur Datenbank herstellen
|
|
mydb = mysql.connector.connect(
|
|
host=os.getenv("MYSQL_HOST"),
|
|
user=os.getenv("MYSQL_USER"),
|
|
password=os.getenv("MYSQL_PASSWORD"),
|
|
database=os.getenv("MYSQL_DATABASE")
|
|
)
|
|
cursor = mydb.cursor()
|
|
|
|
# Tickets abrufen, inklusive customer_ID
|
|
cursor.execute("""
|
|
SELECT t.`number`, t.title, t.createdate, t.`type`, t.customer_ID, tct.firstdate, t.time, s.price, t.service_ID
|
|
FROM Kunden.tickets t
|
|
JOIN Kunden.`tickets.customer.timerange` tct ON t.customer_ID = tct.customer_ID
|
|
JOIN Kunden.services s ON s.service_ID = t.service_ID
|
|
ORDER by t.createdate ASC
|
|
""")
|
|
tickets = cursor.fetchall()
|
|
mydb.close()
|
|
return tickets
|
|
|
|
def fetch_customer_data(customer_id):
|
|
# Verbindung zur Datenbank herstellen
|
|
mydb = mysql.connector.connect(
|
|
host=os.getenv("MYSQL_HOST"),
|
|
user=os.getenv("MYSQL_USER"),
|
|
password=os.getenv("MYSQL_PASSWORD"),
|
|
database=os.getenv("MYSQL_DATABASE")
|
|
)
|
|
cursor = mydb.cursor()
|
|
|
|
# Kundendaten basierend auf customer_ID abrufen
|
|
cursor.execute("""SELECT co.companyname, co.street,co.housenumber, co.postcode, co.city, c.customer FROM company co
|
|
JOIN customers c ON c.customer_ID = co.customer_ID
|
|
WHERE co.customer_id = %s""", (customer_id,))
|
|
customer_data = cursor.fetchone()
|
|
|
|
mydb.close()
|
|
return customer_data
|
|
|
|
def fetch_customer_servicetime(customer_id):
|
|
# Verbindung zur Datenbank herstellen
|
|
mydb = mysql.connector.connect(
|
|
host=os.getenv("MYSQL_HOST"),
|
|
user=os.getenv("MYSQL_USER"),
|
|
password=os.getenv("MYSQL_PASSWORD"),
|
|
database=os.getenv("MYSQL_DATABASE")
|
|
)
|
|
cursor = mydb.cursor()
|
|
|
|
# Kundendaten basierend auf customer_ID abrufen
|
|
cursor.execute("""SELECT servicetime FROM `tickets.customers.servicetime`
|
|
WHERE customer_id = %s""", (customer_id,))
|
|
customer_servicetime = cursor.fetchone()
|
|
|
|
mydb.close()
|
|
return customer_servicetime
|
|
|
|
|
|
def fetch_customer_price(price, customer_ID, service_ID):
|
|
mydb = mysql.connector.connect(
|
|
host=os.getenv("MYSQL_HOST"),
|
|
user=os.getenv("MYSQL_USER"),
|
|
password=os.getenv("MYSQL_PASSWORD"),
|
|
database=os.getenv("MYSQL_DATABASE")
|
|
)
|
|
cursor = mydb.cursor()
|
|
|
|
# Prozentwert aus der Datenbank abrufen
|
|
cursor.execute(f"""SELECT percent FROM `customers.pricechange`
|
|
WHERE customer_ID = {customer_ID} and service_ID = {service_ID}""")
|
|
customer_price_percent = cursor.fetchone()
|
|
mydb.close()
|
|
|
|
# Preis in Minuten umrechnen (da der aktuelle Preis in Stunden angegeben ist)
|
|
price_per_minute = price / 60 # Umrechnung von Stunden auf Minuten
|
|
|
|
# Falls ein Prozentwert existiert, diesen auf den Minutenpreis anwenden
|
|
if customer_price_percent:
|
|
price_per_minute += price_per_minute * (customer_price_percent[0] / 100)
|
|
# print(f"Preis pro Minute nach Aufschlag von {customer_price_percent[0]}%: {price_per_minute:.2f} €")
|
|
else:
|
|
print(f"Standard Preis pro Minute: {price_per_minute:.2f} €")
|
|
|
|
return price_per_minute
|
|
|
|
def replace_text_in_run_with_format(run, key, value):
|
|
if f"{{{key}}}" in run.text:
|
|
run.text = run.text.replace(f"{{{key}}}", str(value))
|
|
run.font.name = 'Verdana'
|
|
run.font.size = Pt(10)
|
|
run.font.bold = False
|
|
run.font.italic = False
|
|
|
|
def insert_page_break(paragraph):
|
|
run = paragraph.add_run()
|
|
run.add_break(WD_BREAK.PAGE)
|
|
|
|
def replace_text_in_paragraph(paragraph, key, value):
|
|
for run in paragraph.runs:
|
|
replace_text_in_run_with_format(run, key, value)
|
|
|
|
def set_cell_border(cell, **kwargs):
|
|
tc = cell._tc
|
|
tcPr = tc.get_or_add_tcPr()
|
|
|
|
borders = OxmlElement('w:tcBorders')
|
|
|
|
for border_name in ["top", "left", "bottom", "right"]:
|
|
border = kwargs.get(border_name, None)
|
|
if border:
|
|
element = OxmlElement(f"w:{border_name}")
|
|
element.set(qn("w:val"), border.get("val", "single"))
|
|
element.set(qn("w:sz"), border.get("sz", "4"))
|
|
element.set(qn("w:space"), border.get("space", "0"))
|
|
element.set(qn("w:color"), border.get("color", "000000"))
|
|
borders.append(element)
|
|
|
|
tcPr.append(borders)
|
|
|
|
def fill_template(doc_path, output_path, data, tickets):
|
|
doc = Document(doc_path)
|
|
|
|
# Platzhalter in normalem Text ersetzen
|
|
for paragraph in doc.paragraphs:
|
|
for key, value in data.items():
|
|
if f"{{{key}}}" in paragraph.text:
|
|
replace_text_in_paragraph(paragraph, key, value)
|
|
if "{page_breaker}" in paragraph.text:
|
|
if len(tickets) >= 7:
|
|
paragraph.text = paragraph.text.replace("{page_breaker}", "")
|
|
insert_page_break(paragraph)
|
|
else:
|
|
paragraph.text = paragraph.text.replace("{page_breaker}", "")
|
|
|
|
# Platzhalter in der ersten Tabelle ersetzen
|
|
first_table = doc.tables[0]
|
|
for row in first_table.rows:
|
|
for cell in row.cells:
|
|
for paragraph in cell.paragraphs:
|
|
for key, value in data.items():
|
|
replace_text_in_paragraph(paragraph, key, value)
|
|
|
|
# Bearbeiten der zweiten Tabelle für Ticketdaten
|
|
second_table = doc.tables[1]
|
|
for ticket in tickets:
|
|
row = second_table.add_row()
|
|
row.cells[0].text = ticket[0] # Ticketnummer
|
|
row.cells[1].text = ticket[1] # Tickettitel
|
|
row.cells[2].text = ticket[2].strftime("%d.%m.%Y") # createdate als String formatieren
|
|
row.cells[3].text = str(ticket[6]) # timerange (time_unit)
|
|
|
|
# Formatierung und Ausrichtung für jede Zelle der neuen Zeile setzen
|
|
for idx, cell in enumerate(row.cells):
|
|
for paragraph in cell.paragraphs:
|
|
if idx == 1:
|
|
paragraph.alignment = WD_ALIGN_PARAGRAPH.LEFT
|
|
else:
|
|
paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
|
|
|
|
for run in paragraph.runs:
|
|
run.font.name = 'Verdana'
|
|
run.font.size = Pt(10)
|
|
run.font.bold = False
|
|
cell.vertical_alignment = WD_ALIGN_VERTICAL.CENTER
|
|
set_cell_border(cell, top={"val": "single", "sz": "4", "color": "000000"},
|
|
bottom={"val": "single", "sz": "4", "color": "000000"},
|
|
left={"val": "single", "sz": "4", "color": "000000"},
|
|
right={"val": "single", "sz": "4", "color": "000000"})
|
|
|
|
# Berechnungen (z.B. Gesamtzeit, Preise)
|
|
gesamt_time_unit = sum(int(ticket[6]) for ticket in tickets)
|
|
data['gesamt_time_unit'] = gesamt_time_unit
|
|
|
|
# Zeit größer als Servicetime
|
|
if gesamt_time_unit >= customer_servicetime[0]:
|
|
data['sl_time_unit'] = gesamt_time_unit + customer_servicetime[0]
|
|
data['sl_minus_unit'] = gesamt_time_unit - customer_servicetime[0]
|
|
data['time_unit_sum'] = gesamt_time_unit + data['zl_time_unit']
|
|
data['price_per_minute'] = customer_price
|
|
|
|
data['price_ex_mwst'] = gesamt_time_unit * data['price_per_minute']
|
|
data['mwst_set'] = data['price_ex_mwst'] * 0.19
|
|
data['sum'] = data['price_ex_mwst'] + data['mwst_set']
|
|
|
|
data['price_ex_mwst'] = f"{data['price_ex_mwst']:.2f}".replace(".",",")
|
|
data['mwst_set'] = f"{data['mwst_set']:.2f}".replace(".",",")
|
|
data['sum'] = f"{data['sum']:.2f}".replace(".",",")
|
|
|
|
|
|
# Platzhalter in der dritten Tabelle ersetzen
|
|
third_table = doc.tables[2]
|
|
for row in third_table.rows:
|
|
for cell in row.cells:
|
|
for paragraph in cell.paragraphs:
|
|
for key, value in data.items():
|
|
if key == "sum":
|
|
# Setze den Text und mache ihn fett
|
|
for run in paragraph.runs:
|
|
if f"{{{key}}}" in run.text:
|
|
run.text = run.text.replace(f"{{{key}}}", str(value))
|
|
run.font.bold = True # Fett setzen
|
|
else:
|
|
replace_text_in_paragraph(paragraph, key, value)
|
|
|
|
doc.save(output_path)
|
|
|
|
# Hauptprogramm
|
|
if __name__ == "__main__":
|
|
tickets = fetch_tickets_from_database()
|
|
service_ID = next(iter(set(ticket[8] for ticket in tickets)))
|
|
price = next(iter(set(ticket[7] for ticket in tickets)))
|
|
customer_ids = set(ticket[4] for ticket in tickets)
|
|
|
|
for customer_id in customer_ids:
|
|
customer_data = fetch_customer_data(customer_id)
|
|
customer_servicetime = fetch_customer_servicetime(customer_id)
|
|
customer_price = fetch_customer_price(price, customer_id, service_ID)
|
|
customer_tickets = [ticket for ticket in tickets if ticket[4] == customer_id]
|
|
|
|
if not customer_data:
|
|
print(f"Keine Kundendaten für Kunden-ID {customer_id} gefunden!")
|
|
continue
|
|
|
|
day = customer_tickets[0][5]
|
|
now = datetime.now()
|
|
if now.month == 1:
|
|
last_month = 12
|
|
year = now.year - 1
|
|
else:
|
|
last_month = now.month - 1
|
|
year = now.year
|
|
startdate = datetime(year, last_month, day)
|
|
enddate = startdate + relativedelta(months=1) - timedelta(days=1)
|
|
|
|
data = {
|
|
"name": customer_data[0],
|
|
"street": customer_data[1],
|
|
"housenumber": customer_data[2],
|
|
"postcode": customer_data[3],
|
|
"city": customer_data[4],
|
|
"customernumber": customer_data[5],
|
|
"year": datetime.now().year,
|
|
"ordernumber": "0001",
|
|
"startdate": startdate.strftime("%d.%m.%Y"),
|
|
"enddate": enddate.strftime("%d.%m.%Y"),
|
|
"today": datetime.now().strftime("%d.%m.%Y"),
|
|
"price_per_minute": customer_price,
|
|
"servicetime": customer_servicetime[0],
|
|
"gesamt_time_unit": 0,
|
|
"price_ex_mwst": 0,
|
|
"sl_time_unit": 0,
|
|
"sl_minus_unit": 0,
|
|
"zl_time_unit": 0,
|
|
"time_unit_sum": 0,
|
|
"mwst_set": 0,
|
|
"sum": 0,
|
|
}
|
|
|
|
output_path = f"apps/ticket_export/exports/RE2024.{customer_data[5]}.{data['ordernumber']}.docx"
|
|
fill_template('apps/ticket_export/template.docx', output_path, data, customer_tickets)
|
|
print("True")
|