Controle de Pagamento Diarista Código Python exe Windows

# Compilar com pyinstaller --windowed --hidden-import babel.numbers --hidden-import babel.localedata nome_do_arquivo.py

import tkinter as tk
from tkinter import ttk, messagebox, simpledialog, filedialog
from tkcalendar import Calendar
from threading import Thread
import sqlite3
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
import locale
from datetime import datetime
from PIL import Image
import os

class CalendarApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Pagamentos Luzia")
        self.center_window(400, 650)

        self.selected_dates = []
        self.db_name = 'pagamentos-diarista.db'

        # Conectar ao banco de dados
        self.conn = sqlite3.connect(self.db_name)
        self.cursor = self.conn.cursor()
        self.create_table()

        # Cria o calendário
        self.cal = Calendar(root, selectmode="day", year=2024, month=8, day=31, date_pattern='dd/mm/yyyy')
        self.cal.pack(pady=20)

        # Cria o botão para marcar a data
        mark_button = ttk.Button(root, text="Marcar Data", command=self.mark_date)
        mark_button.pack(pady=10)

        # Label para mostrar as datas marcadas
        self.label = ttk.Label(root, text="Datas Marcadas:")
        self.label.pack(pady=10)

        self.dates_text = tk.Text(root, height=10, width=40)
        self.dates_text.pack(pady=10)
        self.load_dates()

        # Botão para finalizar e calcular o valor total
        finish_button = ttk.Button(root, text="Finalizar Marcação", command=self.finalize_dates)
        finish_button.pack(pady=10)

        # Botão para gerar PDF
        pdf_button = ttk.Button(root, text="Gerar PDF", command=self.generate_pdf_with_image)
        pdf_button.pack(pady=10)

        # Botão para apagar banco de dados
        clear_button = ttk.Button(root, text="Apagar Banco de Dados", command=self.clear_database)
        clear_button.pack(pady=10)

    def create_table(self):
        self.cursor.execute('''CREATE TABLE IF NOT EXISTS datas (
                                id INTEGER PRIMARY KEY,
                                data TEXT,
                                valor REAL)''')
        self.conn.commit()

    def mark_date(self):
        selected = self.cal.get_date()

        if selected not in self.selected_dates:
            try:
                # Pede ao usuário para informar o valor da marcação
                value = float(simpledialog.askstring("Valor", "Informe o valor para a data marcada (em R$):"))
                self.selected_dates.append((selected, value))
                self.cursor.execute("INSERT INTO datas (data, valor) VALUES (?, ?)", (selected, value))
                self.conn.commit()
                self.dates_text.insert(tk.END, f"{selected} - R${value:.2f}\n")
            except ValueError:
                messagebox.showerror("Erro", "Por favor, insira um valor válido.")

    def load_dates(self):
        self.cursor.execute("SELECT data, valor FROM datas")
        rows = self.cursor.fetchall()
        for row in rows:
            date, value = row
            self.dates_text.insert(tk.END, f"{date} - R${value:.2f}\n")
            self.selected_dates.append((date, value))

    def finalize_dates(self):
        total_value = sum(value for _, value in self.selected_dates)
        selected_dates_str = "\n".join([f"{date} - R${value:.2f}" for date, value in self.selected_dates])
        messagebox.showinfo("Finalização", f"Datas selecionadas:\n{selected_dates_str}\n\nValor total: R${total_value:.2f}")

    def generate_pdf_with_image(self):
        if not self.selected_dates:
            messagebox.showerror("Erro", "Nenhuma data foi marcada.")
            return

        # Solicitar que o usuário selecione uma imagem para ser adicionada ao PDF
        img_path = filedialog.askopenfilename(filetypes=[("Image files", "*.jpg;*.jpeg;*.png")])
        if not img_path:
            messagebox.showerror("Erro", "Nenhuma imagem foi selecionada.")
            return

        # Usar uma thread para gerar o PDF e evitar travamento da interface
        thread = Thread(target=self.process_pdf_generation, args=(img_path,))
        thread.start()

    def process_pdf_generation(self, img_path):
        try:
            # Definir a localidade para Português do Brasil
            locale.setlocale(locale.LC_TIME, 'pt_BR.utf8')

            # Obtendo o nome do mês e o ano da primeira data marcada no calendário
            first_selected_date = self.selected_dates[0][0]
            first_selected_date_obj = datetime.strptime(first_selected_date, '%d/%m/%Y')
            selected_month = first_selected_date_obj.strftime("%B").capitalize()
            selected_year = first_selected_date_obj.strftime("%Y")

            # Adicionar o dia, mês, ano, hora, minuto e segundo ao nome do arquivo para torná-lo único
            current_time = datetime.now().strftime('%d-%m-%Y-%H-%M-%S')
            pdf_filename = f"pagamento-luzia-{selected_month}-{selected_year}-{current_time}.pdf"

            c = canvas.Canvas(pdf_filename, pagesize=letter)

            # Configura o tamanho da fonte
            font_size = 14
            c.setFont("Helvetica", font_size)

            # Título com o mês e ano baseados na primeira data marcada
            title = f"Pagamentos Luzia - {selected_month} de {selected_year}"
            c.drawString(100, 780, title)

            # Subtítulo "Datas"
            c.drawString(100, 750, "Datas:")

            y_position = 730
            for date, value in self.selected_dates:
                c.drawString(100, y_position, f"{date} - R${value:.2f}")
                y_position -= 20

            total_value = sum(value for _, value in self.selected_dates)
            c.drawString(100, y_position - 20, f"Valor Total: R${total_value:.2f}")

            # Adicionar a linha "Pagamento realizado através do PIX na chave [numero]." 7 linhas abaixo do "Valor Total"
            payment_info_y_position = y_position - 20 - (7 * 20)
            c.drawString(100, payment_info_y_position, "Pagamento realizado através do PIX na chave 31xxxxxxx.")

            # Adicionar o rodapé na parte inferior da página com a data e o nome do arquivo em itálico (somente na primeira página)
            footer_y_position = 50  # Próximo ao final da página
            footer_text_2 = f"Arquivo {pdf_filename} gerado em {datetime.now().strftime('%d/%m/%Y')}"

            # Muda o x_position para 10 para alinhar à esquerda
            c.setFont("Helvetica-Oblique", font_size)  # Muda a fonte para itálico
            c.drawString(10, footer_y_position, footer_text_2)

            # Finalizar a primeira página do PDF
            c.showPage()

            # Criar uma nova página para a imagem
            # Carregar a imagem e ajustar a proporção para caber na página
            image = Image.open(img_path)
            image_width, image_height = image.size
            page_width, page_height = letter

            # Calculando a escala mantendo a proporção
            ratio = min(page_width / image_width, page_height / image_height)
            new_width = image_width * ratio
            new_height = image_height * ratio

            # Centralizando a imagem na página
            x_position = (page_width - new_width) / 2
            y_position_image = (page_height - new_height) / 2

            # Desenhar a imagem na nova página
            c.drawImage(img_path, x_position, y_position_image, new_width, new_height)

            c.save()
            messagebox.showinfo("PDF Gerado", f"PDF gerado com sucesso: {pdf_filename}")

        except Exception as e:
            messagebox.showerror("Erro", f"Ocorreu um erro: {str(e)}")

    def clear_database(self):
        # Confirmação antes de apagar o banco de dados
        response = messagebox.askyesno("Confirmação", "Tem certeza que deseja apagar todas as datas?")
        if response:  # Se o usuário confirmar
            self.cursor.execute("DELETE FROM datas")
            self.conn.commit()
            self.selected_dates.clear()
            self.dates_text.delete(1.0, tk.END)
            messagebox.showinfo("Banco de Dados", "Todas as datas foram apagadas com sucesso.")

    def center_window(self, width, height):
        screen_width = self.root.winfo_screenwidth()
        screen_height = self.root.winfo_screenheight()

        x = int((screen_width / 2) - (width / 2))
        y = int((screen_height / 2) - (height / 2))

        self.root.geometry(f'{width}x{height}+{x}+{y}')

    def __del__(self):
        self.conn.close()

if __name__ == "__main__":
    root = tk.Tk()
    app = CalendarApp(root)
    root.mainloop()