sqlwork.py - master - tulupnikov/SQLwork

sqlwork.py
318 строк12 KB
tulupnikov
sqlwork.py
22 сен 2024, 09:08
22 сен 2024, 09:08c44404c
from tkinter import *
from tkinter import ttk
import tkinter as tk
from tkinter import filedialog
import sqlite3
from reportlab.lib.pagesizes import letter #модуль для размера страницы
from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont
from reportlab.lib import colors
from reportlab.platypus import SimpleDocTemplate, Table

def print_base_pdf():  # печать базы в пдф файлы
    global doc_list
    doc_list = ['doc' + str(x) for x in range(0, len(list_table))]
    global table_list
    table_list = ['table' + str(x) for x in range(0, len(list_table))]

    for i in range(0, len(list_table)):
        connect()
        sql_pdf: str = f"SELECT * FROM {list_table[i]}"
        cursor.execute(sql_pdf)
        rows = cursor.fetchall()
        pdfmetrics.registerFont(TTFont('Ubuntu', 'Ubuntu-L.ttf'))
    # делаем док
        doc_list[i] = SimpleDocTemplate(f"table_{list_table[i]}.pdf", pagesize=letter)

    # первая строчка в таблица
        DATA = []
        DATA.append(dict_list[list_table[i]])
        for row in rows:
            DATA.append(row)

        table_list[i] = Table(DATA)

    # table style
        table_list[i].setStyle([('BACKGROUND', (0, 0), (-1, 0), colors.grey),
                              ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
                              ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
                              ('FONTNAME', (0, 0), (-1, -1), 'Ubuntu'),
                              ('TEXTFONT', (0, 0), (-1, -1), 'Ubuntu'),
                              ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
                              ('BACKGROUND', (0, -1), (-1, -1), colors.beige),
                              ('GRID', (0, 0), (-1, -1), 1, colors.black)])

    # делаем таблицу
        doc_list[i].build([table_list[i]])

        con.close()

def connect():
    global  con
    con = sqlite3.connect(filepath)
    global cursor
    cursor = con.cursor()


def item_selected(event):  # получаем в record_row список значений выделеной строки
    k = nb.tabs().index(nb.select()) #Узнаем ID выбраного Frame(nb)
    for row in tree_list[k].selection():
        items = tree_list[k].item(row)
        global record_row
        record_row = items['values']

def delete_row():
    connect()
    k = nb.tabs().index(nb.select())
    sql_dell_row: str = f"DELETE FROM {list_table[k]} WHERE id = ?"

    cursor.execute(sql_dell_row, (record_row[0],))  # удаление выбранной строки по ID

    con.commit()
    cursor.close()
    print_tree()

def clear_tree_all():  # очистка
    for s in range(0, len(list_table)):
        for item in tree_list[s].get_children():
            tree_list[s].delete(item)

def clear_tree(k_id):
    for item in tree_list[k_id].get_children():
            tree_list[k_id].delete(item)
            
def print_tree():
    connect()
    k = nb.tabs().index(nb.select())
    clear_tree(k)
    sql_select_table: str = f"SELECT * FROM {list_table[k]}"
    cursor.execute(sql_select_table)
    rows = cursor.fetchall()
    for row in rows:
        tree_list[k].insert("", tk.END, values=row)
    cursor.close()


def destroy_frame():
    for d in range(0, len(frame_list)):
        for widget in frame_list[d].winfo_children():
            widget.destroy()
            
def close_tab():
    nb.forget("current")

def open_base_file():
    global filepath
    filepath = filedialog.askopenfilename()
    main()

def items_insert():
    list_items = [e.get() for e in entry_list]

    # КОСТЫЛЬ-------------------------------------------
    name = ', '.join(list(dict_list[list_table[nb_id]]))  # склеваем список названий column в name: str
    list_2 = []  #
    for i in range(0, len(dict_list[list_table[nb_id]])):
        list_2.append('?')  #
    name_2 = ', '.join(list_2)  #
    # ---------------------------------------------------

    sql_insert: str = f"INSERT INTO {list_table[nb_id]} ({name}) VALUES ({name_2})"
    connect()
    cursor.execute(sql_insert, (list_items))

    con.commit()
    cursor.close()
    print_tree()

def popit(track):
    return track + "=?"

def items_update():
    list_items = [e.get() for e in entry_list]
    list_items.append(record_row[0])
    print(list_items)
    # КОСТЫЛЬ-------------------------------------------
    name = ", ".join(list(map(popit, dict_list[list_table[nb_id]])))
    # ---------------------------------------------------

    sql_update: str = f"UPDATE {list_table[nb_id]} SET {name} WHERE {dict_list[list_table[nb_id]][0]}=?"
    print(sql_update)
    connect()
    cursor.execute(sql_update, (list_items))

    con.commit()
    cursor.close()
    print_tree()

def base_insert():
    root_insert = Tk()  # делаем окно добавления данных в базу
    root_insert.title(" Insert Base")  # даем название
    root_insert.geometry("200x850")  # размеры
    global nb_id
    nb_id = nb.tabs().index(nb.select()) #ID активной notebook
    height = (len(dict_list[list_table[nb_id]]))*49 #расчет высоты окна в зависимости от кол-ва Entry
    root_insert.geometry(f"200x{height}")  # размеры окна
    global label_list #label_list имен для Label
    label_list = ['label' + str(x) for x in range(0, len(dict_list[list_table[nb_id]]))]
    global entry_list #entry_list имен для Entry
    entry_list = ['entry' + str(x) for x in range(0, len(dict_list[list_table[nb_id]]))]
    #label название colomns from table base
    #entry
    for i in range(0, len(dict_list[list_table[nb_id]])):
        label_list[i] = ttk.Label(root_insert, text=dict_list[list_table[nb_id]][i])
        entry_list[i] = ttk.Entry(root_insert)# создаем текстовое поле ввода
        label_list[i].pack()
        entry_list[i].pack()

    ttk.Button(root_insert, text='ok', command=items_insert).pack()

    root_insert.mainloop()

def base_about():
    root_about = Tk()  # делаем окно update данных в базу
    root_about.title("about Base")  # даем название
    root_about.geometry("1200x400")  # размеры
    connect()
    sql_client: str = f"SELECT {dict_list[list_table[0]][0]}, {dict_list[list_table[0]][5]}, {dict_list[list_table[0]][4]} FROM {list_table[0]} WHERE {dict_list[list_table[0]][4]} = ?"
    cursor.execute(sql_client, (record_row[4], ))
    rows = cursor.fetchall()
    tree_about = ttk.Treeview(root_about)
    tree_about['show'] = 'headings'
    tree_about['column'] = dict_list[list_table[0]]
    tree_about.pack(fill=BOTH, expand=1)
    for row in rows:
        tree_about.insert("", tk.END, values=row)
    cursor.close()
    root_about.mainloop()

def base_update():
    root_update = Tk()  # делаем окно update данных в базу
    root_update.title("Update Base")  # даем название
    root_update.geometry("200x950")  # размеры
    global nb_id
    nb_id = nb.tabs().index(nb.select()) #ID активной notebook
    height = (len(dict_list[list_table[nb_id]]))*49 #расчет высоты окна в зависимости от кол-ва Entry
    root_update.geometry(f"200x{height}")  # размеры окна
    global label_list #label_list имен для Label
    label_list = ['label' + str(x) for x in range(0, len(dict_list[list_table[nb_id]]))]
    global entry_list #entry_list имен для Entry
    entry_list = ['entry' + str(x) for x in range(0, len(dict_list[list_table[nb_id]]))]
    #label название colomns from table base
    #entry
    for i in range(0, len(dict_list[list_table[nb_id]])):
        label_list[i] = ttk.Label(root_update, text=dict_list[list_table[nb_id]][i])
        entry_list[i] = ttk.Entry(root_update)# создаем текстовое поле ввода
        label_list[i].pack()
        entry_list[i].pack()
        entry_list[i].insert(0, record_row[i])

    ttk.Button(root_update, text='ok', command=items_update).pack()

    root_update.mainloop()


def main():
    connect()

    sql_table: str = '''SELECT name
                    FROM sqlite_master
                    WHERE type='table';'''
    cursor.execute(sql_table)
    rows = cursor.fetchall()

    global list_table
    list_table = [] #лист для наименований таблиц из базы
    for row in rows:
        list_table.append(*row)

    global dict_list
    dict_list = {} #dict_table - словарь, keys: имена таблиц, values:  Имена столбцов
    for i in range(0, len(list_table)):
        sql_select: str = f"SELECT * FROM {list_table[i]}"
        cursor.execute(sql_select)
        column = list(map(lambda x: x[0], cursor.description))
        dict_list[list_table[i]] = column

    # набиватель списков в зависимости от len(list_table())
    global frame_list
    frame_list = ['frame' + str(x) for x in range(0, len(list_table))]
    global tree_list
    tree_list = ['tree' + str(y) for y in range(0, len(list_table))]
    global scrb_list
    scrb_list = ['scrb' + str(y) for y in range(0, len(list_table))]

    #делаем закладки с именами таблиц
    global nb
    nb = ttk.Notebook()
    for i in range(0, len(dict_list)):
        frame_list[i] = ttk.Frame(nb)
        nb.pack(expand=True, fill=BOTH)
        nb.add(frame_list[i], text=list_table[i])

    #расставляем таблицы с именами колонок по своим закладкам
    for k in range(0, len(list_table)):
        tree_list[k] = ttk.Treeview(frame_list[k])
        scrb_list[k] = ttk.Scrollbar(frame_list[k], orient="vertical", command=tree_list[k].yview)
        scrb_list[k].pack(side='right', fill='y')
        tree_list[k].configure(yscrollcommand=scrb_list[k].set)
        tree_list[k]['show'] = 'headings'
        tree_list[k]['column'] = dict_list[list_table[k]]
        for i in range(0, len(dict_list[list_table[k]])):
            tree_list[k].heading(i, text=dict_list[list_table[k]][i])
            tree_list[k].column(i, width=100)
        tree_list[k].pack(fill=BOTH, expand=1)
        tree_list[k].bind('<<TreeviewSelect>>', item_selected)

    #расставляем информацию по таблицам из базы данных
    for i in range(0, len(list_table)):
        sql_select_table: str = f"SELECT * FROM {list_table[i]}"
        cursor.execute(sql_select_table)
        rows = cursor.fetchall()
        for row in rows:
            tree_list[i].insert("", tk.END, values=row)


root = Tk()  # делаем окно
root.title(" ver. 001")  # даем название
root.geometry("1200x800")  # размеры

main_menu = Menu(root)

#Файл
file_menu = Menu(main_menu, tearoff=0)
file_menu.add_command(label="Открыть", command=open_base_file)

file_menu.add_command(label="закрыть вкладку", command=close_tab)

file_menu.add_separator()
file_menu.add_command(label="Закрыть", command=root.destroy)

tree_menu = Menu(main_menu, tearoff=0)
tree_menu.add_command(label="Добавить данные", command=base_insert)
tree_menu.add_command(label="Редактировать данные", command=base_update)
tree_menu.add_command(label="Удалить строку", command=delete_row)
tree_menu.add_separator()
tree_menu.add_command(label="вывести table", command=print_tree)
tree_menu.add_command(label="очистить table", command=clear_tree_all)
tree_menu.add_command(label="About", command=base_about)

report_menu = Menu(main_menu, tearoff=0)
report_menu.add_command(label="Отчет")

user_menu = Menu(main_menu, tearoff=0)
user_menu.add_command(label="Сохранить в *.pdf", command=print_base_pdf)

root.config(menu=user_menu)

root.config(menu=file_menu)

main_menu.add_cascade(label="File", menu=file_menu)
main_menu.add_cascade(label="Таблица", menu=tree_menu)
main_menu.add_cascade(label="Отчеты", menu=report_menu)
main_menu.add_cascade(label="Print to PDF", menu=user_menu)


root.config(menu=main_menu)

root.mainloop()