Janela de Favoritos com edição e exclusão (Python)

#EDITADO EM 13/06/2023 ÀS 21:56

import tkinter as tk
from tkinter import ttk
from tkinter import messagebox
import webbrowser
import csv
from bs4 import BeautifulSoup
import requests
from datetime import datetime
import os
import ctypes


# Função para minimizar a janela do terminal
def minimize_window():
    # Obtém o identificador da janela do terminal
    hwnd = ctypes.windll.kernel32.GetConsoleWindow()

    # Minimiza a janela do terminal
    ctypes.windll.user32.ShowWindow(hwnd, 6)  # 6 representa o comando para minimizar a janela

    # Exibe mensagem informando que o programa está sendo executado
    print("O programa está sendo executado. A janela do terminal será minimizada.")


# Minimiza a janela do terminal
minimize_window()


class URLManager:
    def __init__(self, root):
        self.root = root
        self.current_sort_column = None  # Manter o controle da coluna atualmente ordenada
        self.current_sort_direction = True  # True para ordem crescente, False para ordem decrescente
        self.create_main_window()

    def create_main_window(self):
        self.root.title("Gerenciador de Favoritos")
        window_width = 1366
        window_height = 768

        screen_width = self.root.winfo_screenwidth()
        screen_height = self.root.winfo_screenheight()

        x = (screen_width - window_width) // 2
        y = (screen_height - window_height) // 2

        self.root.geometry(f"{window_width}x{window_height}+{x}+{y}")

        self.create_treeview()
        self.create_menu()

        # Adicionar a mensagem no canto esquerdo da janela
        message_label = tk.Label(self.root, text="Gerenciador de Favoritos (2023)", anchor="w", padx=10, pady=5)
        message_label.pack(side="left", anchor="sw")

    def create_treeview(self):
        tree_frame = ttk.Frame(self.root)
        tree_frame.pack(fill="both", expand=True)

        self.tree = ttk.Treeview(tree_frame, columns=("Title", "URL", "Categoria", "Data e Hora"), show="headings")
        self.tree.heading("Title", text="Título", command=lambda: self.sort_by_column("Title"))
        self.tree.heading("URL", text="URL")
        self.tree.heading("Categoria", text="Categoria", command=lambda: self.sort_by_column("Categoria"))
        self.tree.heading("Data e Hora", text="Data e Hora", command=lambda: self.sort_by_column("Data e Hora"))
        self.tree.pack(side="left", fill="both", expand=True)

        scrollbar = ttk.Scrollbar(tree_frame, orient="vertical", command=self.tree.yview)
        scrollbar.pack(side="right", fill="y")
        self.tree.configure(yscrollcommand=scrollbar.set)

        self.tree.configure(height=10)
        self.tree.column("#0", width=0)
        self.tree.column("Title", width=300)
        self.tree.column("URL", width=400)
        self.tree.column("Categoria", width=150)
        self.tree.column("Data e Hora", width=200)

        self.load_data()

        self.tree.bind("<Double-1>", self.open_url)

    def create_menu(self):
        menu_bar = tk.Menu(self.root)
        self.root.config(menu=menu_bar)

        acoes_menu = tk.Menu(menu_bar, tearoff=0)
        menu_bar.add_cascade(label="Ações", menu=acoes_menu)
        acoes_menu.add_command(label="Cadastrar", command=self.cadastrar)
        acoes_menu.add_command(label="Editar", command=self.editar)
        acoes_menu.add_command(label="Excluir", command=self.excluir)
        acoes_menu.add_separator()
        acoes_menu.add_command(label="Exportar para HTML", command=self.exportar_para_html)
        acoes_menu.add_command(label="Sair", command=self.sair)

    def load_data(self):
        try:
            with open('sites.csv', 'r', encoding='utf-8') as file:
                reader = csv.reader(file)
                for row in reader:
                    if len(row) >= 4:
                        title = row[0]
                        url = row[1]
                        category = row[2]
                        timestamp = row[3]
                        self.tree.insert('', 'end', values=(title, url, category, timestamp))
        except FileNotFoundError:
            messagebox.showerror("Erro", "Arquivo 'sites.csv' não encontrado.")

    def cadastrar(self):
        cadastrar_window = tk.Toplevel(self.root)
        cadastrar_window.title("Cadastrar URL")
        cadastrar_window.geometry("+%d+%d" % (
            (self.root.winfo_screenwidth() - cadastrar_window.winfo_reqwidth()) // 2,
            (self.root.winfo_screenheight() - cadastrar_window.winfo_reqheight()) // 2))

        url_label = tk.Label(cadastrar_window, text="URL:")
        url_label.pack()
        url_entry = tk.Entry(cadastrar_window, width=100)
        url_entry.pack()

        category_label = tk.Label(cadastrar_window, text="Categoria:")
        category_label.pack()
        category_combobox = ttk.Combobox(cadastrar_window, values=[
            "Adulto", "Compras", "Cinema", "Comportamento", "Curiosidades", "Downloads", "Downloads-Filmes", "Engraçado",
            "Tecnologia", "iOS", "Android", "Música", "Notícias", "Política", "Programação", "Streaming", "Utilitários",
            "Variedades", "Veículos", "Youtube"])

        category_combobox.pack()

        url_entry.bind("<Button-3>", lambda event: url_entry.focus_set())
        url_entry_menu = tk.Menu(tearoff=0)
        url_entry_menu.add_command(label="Colar", command=lambda: url_entry.event_generate("<<Paste>>"))
        url_entry_menu.add_command(label="Copiar", command=lambda: url_entry.event_generate("<<Copy>>"))
        url_entry_menu.add_command(label="Recortar", command=lambda: url_entry.event_generate("<<Cut>>"))
        url_entry.bind("<Button-3>", lambda event: url_entry_menu.post(event.x_root, event.y_root))

        salvar_button = tk.Button(cadastrar_window, text="Cadastrar",
                                  command=lambda: self.salvar_url(url_entry, category_combobox, cadastrar_window))
        salvar_button.pack()

    def salvar_url(self, url_entry, category_combobox, cadastrar_window):
        url = url_entry.get()
        category = category_combobox.get()
        if url and category:
            try:
                response = requests.get(url)
                soup = BeautifulSoup(response.text, 'html.parser')
                title = soup.title.string
                current_time = datetime.now().strftime("%d/%m/%Y %H:%M:%S")

                with open('sites.csv', 'a', newline='', encoding='utf-8') as file:
                    writer = csv.writer(file)
                    writer.writerow([title, url, category, current_time])

                self.tree.insert('', 'end', values=(title, url, category, current_time))
                url_entry.delete(0, 'end')

                messagebox.showinfo("Cadastrar", "URL cadastrada com sucesso.")
                cadastrar_window.destroy()

            except:
                messagebox.showerror("Erro", "Erro ao acessar a URL.")

        else:
            messagebox.showerror("Erro", "Digite uma URL e selecione uma categoria.")

    def excluir(self):
        item = self.tree.selection()
        if item:
            confirm = messagebox.askyesno("Confirmação", "Deseja realmente excluir a URL selecionada?")
            if confirm:
                selected_item = self.tree.selection()[0]
                title = self.tree.item(selected_item)['values'][0]
                url = self.tree.item(selected_item)['values'][1]
                self.tree.delete(selected_item)
                messagebox.showinfo("Exclusão", "URL excluída com sucesso.")

                self.remove_registro_csv(title, url)
        else:
            messagebox.showerror("Erro", "Selecione uma URL para excluir.")

    def editar(self):
        item = self.tree.selection()
        if item:
            selected_item = self.tree.selection()[0]
            old_title = self.tree.item(selected_item)['values'][0]
            old_url = self.tree.item(selected_item)['values'][1]
            old_category = self.tree.item(selected_item)['values'][2]

            edit_window = tk.Toplevel(self.root)
            edit_window.title("Editar URL")
            edit_window.geometry("+%d+%d" % (
                (self.root.winfo_screenwidth() - edit_window.winfo_reqwidth()) // 2,
                (self.root.winfo_screenheight() - edit_window.winfo_reqheight()) // 2))

            title_label = tk.Label(edit_window, text="Título:")
            title_label.pack()
            title_entry = tk.Entry(edit_window, width=100)
            title_entry.insert(0, old_title)
            title_entry.pack()

            url_label = tk.Label(edit_window, text="URL:")
            url_label.pack()
            url_entry = tk.Entry(edit_window, width=100)
            url_entry.insert(0, old_url)
            url_entry.pack()

            category_label = tk.Label(edit_window, text="Categoria:")
            category_label.pack()
            category_combobox = ttk.Combobox(edit_window, values=[
                "Adulto", "Compras", "Cinema", "Comportamento", "Curiosidades", "Downloads", "Downloads-Filmes", "Engraçado",
                "Tecnologia", "iOS", "Android", "Música", "Notícias", "Política", "Programação", "Streaming", "Utilitários",
                "Variedades", "Veículos", "Youtube"])
            category_combobox.set(old_category)
            category_combobox.pack()

            salvar_button = tk.Button(edit_window, text="Salvar",
                                    command=lambda: self.salvar_edicao(title_entry, url_entry, category_combobox, old_title, old_url, edit_window))
            salvar_button.pack()

        else:
            messagebox.showerror("Erro", "Selecione uma URL para editar.")

    def salvar_edicao(self, title_entry, url_entry, category_combobox, old_title, old_url, edit_window):
        new_title = title_entry.get()
        new_url = url_entry.get()
        new_category = category_combobox.get()

        if new_title and new_url and new_category:
            selected_item = self.tree.selection()[0]
            self.tree.item(selected_item, values=(new_title, new_url, new_category))

            edit_window.destroy()
            self.atualizar_registro_csv(old_title, old_url, new_title, new_url, new_category)
        else:
            messagebox.showerror("Erro", "Preencha todos os campos.")

    def remove_registro_csv(self, title, url):
        rows = []
        with open('sites.csv', 'r', encoding='utf-8') as file:
            reader = csv.reader(file)
            for row in reader:
                if row[0] != title or row[1] != url:
                    rows.append(row)

        with open('sites.csv', 'w', newline='', encoding='utf-8') as file:
            writer = csv.writer(file)
            writer.writerows(rows)

    def atualizar_registro_csv(self, old_title, old_url, new_title, new_url, new_category):
        rows = []
        with open('sites.csv', 'r', encoding='utf-8') as file:
            reader = csv.reader(file)
            for row in reader:
                if row[0] == old_title and row[1] == old_url:
                    current_time = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
                    rows.append([new_title, new_url, new_category, current_time])
                else:
                    rows.append(row)

        with open('sites.csv', 'w', newline='', encoding='utf-8') as file:
            writer = csv.writer(file)
            writer.writerows(rows)

    def open_url(self, event):
        items = self.tree.selection()
        if not items:
            return  # Não faz nada se nenhum item estiver selecionado

        item = items[0]
        url = self.tree.item(item)['values'][1]
        webbrowser.open(url)

    def exportar_para_html(self):
        current_time = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
        filename = f"{current_time.replace('/', '_').replace(':', '_')}.html"
        links = []

        with open('sites.csv', 'r', encoding='utf-8') as file:
            reader = csv.reader(file)
            for row in reader:
                url = row[1]
                link_html = f"<a href='{url}'>{url}</a>"
                links.append(link_html)

        html_content = f"""
        <!DOCTYPE html>
        <html>
        <head>
            <title>Links</title>
        </head>
        <body>
            <h1>Links</h1>
            <ul>
                {''.join(f'<li>{link}</li>' for link in links)}
            </ul>
            <p>Exportado em {current_time}</p>
        </body>
        </html>
        """

        current_dir = os.path.dirname(os.path.abspath(__file__))
        file_path = os.path.join(current_dir, filename)

        with open(file_path, 'w', encoding='utf-8') as file:
            file.write(html_content)

        messagebox.showinfo("Exportar para HTML", f"Arquivo HTML '{filename}' gerado com sucesso!")

    def sair(self):
        self.root.quit()

    def sort_by_column(self, column):
        if column == "URL":
            return  # Não faz nada se a coluna selecionada for "URL"

        if self.current_sort_column == column:
            # Alternar a direção da ordenação
            self.current_sort_direction = not self.current_sort_direction
        else:
            # Estabelecer a coluna atualmente ordenada e a direção como padrão
            self.current_sort_column = column
            self.current_sort_direction = True

        items = self.tree.get_children()
        sorted_items = sorted(items, key=lambda x: self.get_column_value(x, column), reverse=not self.current_sort_direction)
        for index, item in enumerate(sorted_items, start=0):
            self.tree.move(item, '', index)

    def get_column_value(self, item, column):
        values = self.tree.item(item)['values']
        if column == "Title":
            return values[0]
        elif column == "URL":
            return values[1]
        elif column == "Categoria":
            return values[2]
        elif column == "Data e Hora":
            return values[3]
        else:
            return None


root = tk.Tk()
url_manager = URLManager(root)
root.mainloop()