Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

import tkinter as tk from tkinter import ttk, messagebox, filedialog import sqlite3 from…

  1. User

    import tkinter as tk from tkinter import ttk, messagebox, filedialog import sqlite3 from datetime import datetime import re import pandas as pd import unicodedata import getpass import locale import openpyxl from openpyxl.utils.dataframe import dataframe_to_rows from openpyxl.styles import Alignment from PIL import Image, ImageTk

    class RehberUygulamasi: def init(self, master): self.master = master self.master.title("Rehber Uygulaması") self.master.geometry("1200x800")

        # Stil oluşturma
        style = ttk.Style()
        style.configure("TLabel", font=("Arial", 12))  # Etiketlerin yazı tipi boyutunu artır
        style.configure("TEntry", font=("Arial", 12))  # Giriş alanlarının yazı tipi boyutunu artır
        style.configure("TButton", font=("Arial", 12))  # Butonların yazı tipi boyutunu artır
        style.configure("Treeview.Heading", font=("Arial", 10, "bold"))  # Tablo başlıklarının boyutunu artır
        style.configure("Treeview", font=("Arial", 12))  # Treeview içindeki yazı tipi
        style.configure("Treeview", rowheight=35)  # Satır yüksekliğini artır
    
        self.create_widgets()
        self.create_database()
        self.update_database_schema()  # Yeni eklenen fonksiyon
        self.load_data()
        self.update_clock()
        self.create_log_table()
        self.username = getpass.getuser()  # Mevcut kullanıcının adını al
    
    def create_widgets(self):
        # Logo
        logo_frame = ttk.Frame(self.master, padding="10")
        logo_frame.grid(row=0, column=1, sticky=tk.NE, padx=10, pady=10)
    
        logo_image = Image.open("logo.png")
        logo_image = logo_image.resize((100, 100), Image.Resampling.LANCZOS)
        self.logo_photo = ImageTk.PhotoImage(logo_image)
        self.logo_label = ttk.Label(logo_frame, image=self.logo_photo)
        self.logo_label.grid(row=0, column=0)
    
    
        # Giriş alanları
        input_frame = ttk.Frame(self.master, padding="10")
        input_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
    
        ttk.Label(input_frame, text="Trafo Merkezi:").grid(row=0, column=0, sticky=tk.W,pady=3)
        self.trafo_merkezi = ttk.Entry(input_frame, width=50,font=50)
        self.trafo_merkezi.grid(row=0, column=1, padx=5, pady=2,)
    
        ttk.Label(input_frame, text="PAX1:").grid(row=1, column=0, sticky=tk.W,pady=3)
        self.pax1 = ttk.Entry(input_frame, width=50,font=50)
        self.pax1.grid(row=1, column=1, padx=5, pady=2)
    
        ttk.Label(input_frame, text="PAX2:").grid(row=2, column=0, sticky=tk.W,pady=3)
        self.pax2 = ttk.Entry(input_frame, width=50,font=50)
        self.pax2.grid(row=2, column=1, padx=5, pady=2)
    
        ttk.Label(input_frame, text="Telefon1:").grid(row=3, column=0, sticky=tk.W,pady=3)
        self.telefon1 = ttk.Entry(input_frame, width=50,font=50)
        self.telefon1.grid(row=3, column=1, padx=5, pady=2)
    
        ttk.Label(input_frame, text="Telefon2:").grid(row=4, column=0, sticky=tk.W,pady=3)
        self.telefon2 = ttk.Entry(input_frame, width=50,font=50)
        self.telefon2.grid(row=4, column=1, padx=5, pady=2)
    
        ttk.Label(input_frame, text="Yetkili:").grid(row=5, column=0, sticky=tk.W,pady=3)
        self.yetkili = ttk.Entry(input_frame, width=50,font=50)
        self.yetkili.grid(row=5, column=1, padx=5, pady=2)
    
        self.button_frame = ttk.Frame(self.master, padding="10")
        self.button_frame.grid(row=1, column=0, sticky=(tk.W, tk.E))
    
        # Butonlar
        self.button_frame = ttk.Frame(self.master, padding="10")
        self.button_frame.grid(row=1, column=0, sticky=(tk.W, tk.E))
    
        ttk.Button(self.button_frame, text="Logları Görüntüle", command=self.view_logs).grid(row=0, column=5, padx=5)
    
        ttk.Button(self.button_frame, text="Ekle", command=self.add_record).grid(row=0, column=0, padx=5)
        ttk.Button(self.button_frame, text="Düzenle", command=self.edit_record).grid(row=0, column=1, padx=5)
        ttk.Button(self.button_frame, text="Sil", command=self.delete_record).grid(row=0, column=2, padx=5)
        ttk.Button(self.button_frame, text="Excel'e Aktar", command=self.export_to_excel).grid(row=0, column=3, padx=5)
        ttk.Button(self.button_frame, text="Rehberi Güncelle", command=self.update_records).grid(row=0, column=4,padx=5)
    
    
        ttk.Button(self.button_frame, text="Komşuları Listele", command=self.list_neighbors).grid(row=0, column=6,
                                                                                                  padx=5)  # Yeni buton
    
        # Filtreleme
        filter_frame = ttk.Frame(self.master, padding="10")
        filter_frame.grid(row=2, column=0, sticky=(tk.W, tk.E))
    
        ttk.Label(filter_frame, text="Filtrele:").grid(row=0, column=0, sticky=tk.W,pady=10)
        self.filter_entry = ttk.Entry(filter_frame, width=57,font=50)
        self.filter_entry.grid(row=0, column=1, padx=5)
        self.filter_entry.bind("<KeyRelease>", self.filter_data)
    
        # Treeview
        self.tree = ttk.Treeview(self.master,
                                 columns=("Trafo Merkezi", "PAX1", "PAX2", "Telefon1", "Telefon2", "Yetkili"),
                                 show="headings")
        self.tree.grid(row=3, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(10, 0))
    
        # Sütun başlıklarını ve genişliklerini ayarla
        column_widths = {
            "Trafo Merkezi": 200,
            "PAX1": 115,
            "PAX2": 115,
            "Telefon1": 200,
            "Telefon2": 200,
            "Yetkili": 150,
        }
    
        for col in self.tree["columns"]:
            self.tree.heading(col, text=col, command=lambda c=col: self.sort_by_column(c, False))
            self.tree.column(col, width=column_widths.get(col, 100), anchor=tk.W)
    
        self.tree.bind("<<TreeviewSelect>>", self.item_selected)
    
        # Scrollbar
        scrollbar = ttk.Scrollbar(self.master, orient=tk.VERTICAL, command=self.tree.yview)
        scrollbar.grid(row=3, column=1, sticky=(tk.N, tk.S))
        self.tree.configure(yscrollcommand=scrollbar.set)
    
        # Saat
        self.clock_label = ttk.Label(self.master, text="", font=("Arial", 18, "bold"))
        self.clock_label.grid(row=4, column=1, sticky=tk.SE, padx=10, pady=10)
    
        # Bilgi yazısı
        self.info_label = ttk.Label(self.master, text="Bu program Abdullah YAR tarafından yapılmıştır.",
                                    font=("Arial", 10, "italic"))
        self.info_label.grid(row=4, column=0, sticky=tk.SW, padx=10, pady=10)
    
        # Configure grid weights
        self.master.grid_columnconfigure(0, weight=1)
        self.master.grid_columnconfigure(1, weight=0)  # Logo sütununu ağırlıksız yap
        self.master.grid_rowconfigure(3, weight=1)
    
        for col in self.tree["columns"]:
            self.tree.heading(col, text=col, command=lambda c=col: self.sort_by_column(c, False))
            self.tree.column(col, width=column_widths.get(col, 100), anchor=tk.W)
    
        def create_widgets(self):
            # ... (diğer widget'lar)
    
            # Butonlar
            self.button_frame = ttk.Frame(self.master, padding="10")
            self.button_frame.grid(row=1, column=0, sticky=(tk.W, tk.E))
    
            ttk.Button(self.button_frame, text="Komşuları Listele", command=self.list_neighbors).grid(row=0, column=6,
                                                                                                      padx=5)  # Yeni buton
            # ... (diğer butonlar)
    
    def list_neighbors(self):
            selected_item = self.tree.selection()
            if not selected_item:
                messagebox.showwarning("Uyarı", "Lütfen bir kayıt seçin.")
                return
    
            # Seçilen kaydın verilerini al
            trafo_merkezi = self.tree.item(selected_item)['values'][0]
    
            # Komşu veritabanında ara
            self.search_neighbors(trafo_merkezi)
    
    def search_neighbors(self, trafo_merkezi):
            try:
                conn = sqlite3.connect("komsu.db")
                cursor = conn.cursor()
    
                # Komşu veritabanında arama yap
                cursor.execute("SELECT * FROM komsu_tm WHERE Trafo_merkezi=?", (trafo_merkezi,))
                results = cursor.fetchall()
                conn.close()
    
                if results:
                    # Sonuçları rehber veritabanında ara
                    self.list_neighbors_in_rehber(results)
                else:
                    messagebox.showinfo("Sonuç Yok", f"{trafo_merkezi} için komşu bulunamadı.")
    
            except sqlite3.Error as e:
                messagebox.showerror("Veritabanı Hatası", f"Hata: {str(e)}")
    
    def list_neighbors_in_rehber(self, neighbors):
            # Rehber veritabanında komşulara ait bilgileri ara
            try:
                conn = sqlite3.connect("rehber.db")
                cursor = conn.cursor()
    
                # Komşuların bilgilerini saklayacağımız bir liste
                neighbor_info = []
    
                for neighbor in neighbors:
                    # Burada neighbor[1] komşunun adı veya kimliği olabilir
                    cursor.execute("SELECT * FROM rehber WHERE trafo_merkezi=?", (neighbor[1],))
                    info = cursor.fetchall()
                    neighbor_info.extend(info)  # Bilgileri listeye ekle
    
                conn.close()
    
                # Eğer bilgiler bulunduysa, ekranda göster
                if neighbor_info:
                    self.display_neighbor_info(neighbor_info)
                else:
                    messagebox.showinfo("Sonuç Yok", "Rehberde komşulara ait bilgi bulunamadı.")
    
            except sqlite3.Error as e:
                messagebox.showerror("Veritabanı Hatası", f"Hata: {str(e)}")
    
    def display_neighbor_info(self, neighbor_info):
        # Yeni bir pencere oluştur
        neighbor_window = tk.Toplevel(self.master)
        neighbor_window.title("Komşu Bilgileri")
        neighbor_window.geometry("1000x500")
    
        # Treeview oluştur
        komsu_tree = ttk.Treeview(neighbor_window,
                                  columns=("Trafo Merkezi", "PAX1", "PAX2", "Telefon1", "Telefon2", "Yetkili"),
                                  show="headings")
        komsu_tree.pack(fill=tk.BOTH, expand=True)
    
        # Sütun başlıklarını ayarla
        for col in komsu_tree["columns"]:
            komsu_tree.heading(col, text=col)
    
        # Komşu bilgilerini Treeview'da göster
        for info in neighbor_info:
            komsu_tree.insert("", "end",
                              values=(info[1], info[2], info[3], info[4], info[5], info[6]))  # Bilgileri ekle
    
        # Scrollbar ekle
        scrollbar = ttk.Scrollbar(neighbor_window, orient=tk.VERTICAL, command=komsu_tree.yview)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        komsu_tree.configure(yscrollcommand=scrollbar.set)
    
    
    
    
    
    
    
    
    def sort_by_column(self, col, reverse):
        # Locale ayarlarını Türkçe'ye göre yap
        locale.setlocale(locale.LC_COLLATE, 'tr_TR.UTF-8')
    
        column_index = self.tree["columns"].index(col)
        items = list(self.tree.get_children())
    
        # Türkçe alfabeye göre sıralama yapmak için özel bir fonksiyon
        def custom_sort_key(item):
            value = self.tree.item(item, 'values')[column_index]
            # Eğer değer tamamen sayılardan oluşuyorsa, en sona koymak için önek ekle
            if value.isdigit():
                return "zzz" + value
            # Aksi halde normal sıralama yap
            return locale.strxfrm(value)
    
        # Özel sıralama fonksiyonunu kullanarak sırala
        items.sort(key=custom_sort_key, reverse=reverse)
    
        # Mevcut sıralama yönünü güncelle
        self.tree.heading(col, command=lambda: self.sort_by_column(col, not reverse))
    
        # Sıralı öğeleri yeniden ekle
        for index, item in enumerate(items):
            self.tree.move(item, '', index)
    
    def create_database(self):
        conn = sqlite3.connect("rehber.db")
        cursor = conn.cursor()
        cursor.execute("""
           CREATE TABLE IF NOT EXISTS rehber (
               id INTEGER PRIMARY KEY,
               trafo_merkezi TEXT,
               pax1 TEXT,
               pax2 TEXT,
               telefon1 TEXT,
               telefon2 TEXT,
               yetkili TEXT
           )
           """)
        conn.commit()
        conn.close()
    
    
    def create_log_table(self):
        conn = sqlite3.connect("rehber.db")
        cursor = conn.cursor()
        cursor.execute("""
        CREATE TABLE IF NOT EXISTS log (
            id INTEGER PRIMARY KEY,
            action TEXT,
            trafo_merkezi TEXT,
            old_data TEXT,
            new_data TEXT,
            timestamp DATETIME,
            username TEXT
        )
        """)
        conn.commit()
        conn.close()
    
    def update_database_schema(self):
        conn = sqlite3.connect("rehber.db")
        cursor = conn.cursor()
    
        # Log tablosunun var olup olmadığını kontrol et
        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='log'")
        table_exists = cursor.fetchone()
    
        if not table_exists:
            # Log tablosu yoksa oluştur
            cursor.execute("""
            CREATE TABLE log (
                id INTEGER PRIMARY KEY,
                action TEXT,
                trafo_merkezi TEXT,
                old_data TEXT,
                new_data TEXT,
                timestamp DATETIME,
                username TEXT
            )
            """)
        else:
            # Log tablosu varsa, username sütununun olup olmadığını kontrol et
            cursor.execute("PRAGMA table_info(log)")
            columns = cursor.fetchall()
            column_names = [column[1] for column in columns]
    
            if 'username' not in column_names:
                # username sütunu yoksa ekle
                cursor.execute("ALTER TABLE log ADD COLUMN username TEXT")
    
        conn.commit()
        conn.close()
    
    def add_log(self, action, trafo_merkezi, old_data=None, new_data=None):
        conn = sqlite3.connect("rehber.db")
        cursor = conn.cursor()
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    
        try:
            # Log ekleme işlemi
            cursor.execute("""
            INSERT INTO log (action, trafo_merkezi, old_data, new_data, timestamp, username)
            VALUES (?, ?, ?, ?, ?, ?)
            """, (action, trafo_merkezi, str(old_data), str(new_data), timestamp, self.username))
            conn.commit()
    
            # Log tablosundaki kayıt sayısını kontrol et ve gerekirse en eski 100 kaydı sil
            cursor.execute("SELECT COUNT(*) FROM log")
            count = cursor.fetchone()[0]
    
            if count > 400:
                # En eski 100 kaydı sil
                cursor.execute("""
                DELETE FROM log
                WHERE id IN (
                    SELECT id FROM log
                    ORDER BY timestamp ASC
                    LIMIT 100
                )
                """)
                conn.commit()
    
        except sqlite3.OperationalError as e:
            messagebox.showerror("Veritabanı Hatası", f"Log eklenirken bir hata oluştu: {str(e)}")
        finally:
            conn.close()
    
    def load_data(self):
        self.tree.delete(*self.tree.get_children())
        conn = sqlite3.connect("rehber.db")
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM rehber")
        rows = cursor.fetchall()
        for index, row in enumerate(rows):
            color = '#f0f0f0' if index % 2 == 0 else '#ffffff'
            self.tree.insert("", "end", values=row[1:], tags=("row",))
            self.tree.tag_configure("row", background=color)
        conn.close()
    
    def add_record(self):
        trafo_merkezi = self.trafo_merkezi.get()
        values = (
            trafo_merkezi,
            self.pax1.get(),
            self.pax2.get(),
            self.telefon1.get(),
            self.telefon2.get(),
            self.yetkili.get()
        )
    
        if trafo_merkezi:  # Sadece trafo_merkezi'nin boş olup olmadığını kontrol et
            conn = sqlite3.connect("rehber.db")
            cursor = conn.cursor()
    
            # Aynı trafo_merkezi ile var olup olmadığını kontrol et
            cursor.execute("SELECT COUNT(*) FROM rehber WHERE trafo_merkezi=?", (trafo_merkezi,))
            exists = cursor.fetchone()[0] > 0
    
            if exists:
                messagebox.showwarning("Kayıt Var", "Bu trafo merkezi zaten mevcut.")
            else:
                cursor.execute(
                    "INSERT INTO rehber (trafo_merkezi, pax1, pax2, telefon1, telefon2, yetkili) VALUES (?, ?, ?, ?, ?, ?)",
                    values
                )
                conn.commit()
                messagebox.showinfo("Başarılı", "Kayıt başarıyla eklendi.")
    
                # Log kaydı ekleyin
                self.add_log("Ekleme", trafo_merkezi, None, values)
    
            conn.close()
            self.load_data()
            self.highlight_new_entry(trafo_merkezi)
            self.clear_entries()
        else:
            messagebox.showwarning("Eksik Alan", "Trafo merkezi alanını doldurun.")
    
    def highlight_new_entry(self, trafo_merkezi):
        # Treeview'deki tüm satırları kontrol et ve yeni eklenen satırı bul
        for item in self.tree.get_children():
            values = self.tree.item(item, 'values')
            if values and values[0] == trafo_merkezi:
                self.tree.item(item, tags=("new",))
                self.tree.tag_configure("new", background="#d0f0c0")  # Yeşil renk
                break
    
    def edit_record(self):
        selected_item = self.tree.selection()
        if not selected_item:
            messagebox.showwarning("Uyarı", "Lütfen düzenlenecek bir kayıt seçin.")
            return
    
        old_values = self.tree.item(selected_item)['values']
        new_values = (
            self.trafo_merkezi.get(),
            self.pax1.get(),
            self.pax2.get(),
            self.telefon1.get(),
            self.telefon2.get(),
            self.yetkili.get(),
            old_values[0]
        )
    
        conn = sqlite3.connect("rehber.db")
        cursor = conn.cursor()
        cursor.execute(
            "UPDATE rehber SET trafo_merkezi=?, pax1=?, pax2=?, telefon1=?, telefon2=?, yetkili=? WHERE trafo_merkezi=?",
            new_values)
        conn.commit()
        conn.close()
    
        self.add_log("Düzenleme", old_values[0], old_values, new_values[:-1])
    
        self.load_data()
        self.clear_entries()
    
    def delete_record(self):
        selected_item = self.tree.selection()
        if not selected_item:
            messagebox.showwarning("Uyarı", "Lütfen silinecek bir kayıt seçin.")
            return
        if messagebox.askyesno("Onay", "Seçili kaydı silmek istediğinizden emin misiniz?"):
            trafo_merkezi = self.tree.item(selected_item)['values'][0]
            old_values = self.tree.item(selected_item)['values']
    
            conn = sqlite3.connect("rehber.db")
            cursor = conn.cursor()
            cursor.execute("DELETE FROM rehber WHERE trafo_merkezi=?", (trafo_merkezi,))
            conn.commit()
            conn.close()
    
            self.add_log("Silme", trafo_merkezi, old_values)
    
            self.load_data()
            self.clear_entries()
    
    def view_logs(self):
        conn = sqlite3.connect("rehber.db")
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM log ORDER BY timestamp DESC")
        logs = cursor.fetchall()
        conn.close()
    
        log_window = tk.Toplevel(self.master)
        log_window.title("Log Kayıtları")
        log_window.geometry("1000x600")
    
        log_tree = ttk.Treeview(log_window,
                                columns=("Yapılan İş", "Trafo Merkezi", "Eski Veri", "Yeni Veri", "Saat", "Kullanıcı"),
                                show="headings")
        log_tree.pack(fill=tk.BOTH, expand=True)
    
        for col in log_tree["columns"]:
            log_tree.heading(col, text=col)
            log_tree.column(col, width=150)
    
        for log in logs:
            log_tree.insert("", "end", values=log[1:])
    
        ttk.Button(log_window, text="Kapat", command=log_window.destroy).pack()
    
    def clear_entries(self):
        for entry in (self.trafo_merkezi, self.pax1, self.pax2, self.telefon1, self.telefon2, self.yetkili):
            entry.delete(0, tk.END)
    
    def filter_data(self, event=None):
        self.clear_input_fields()
    
        search_term = self.filter_entry.get()  # Büyük/küçük harf korunuyor
        self.tree.delete(*self.tree.get_children())
    
        conn = sqlite3.connect("rehber.db")
        cursor = conn.cursor()
    
        cursor.execute("SELECT * FROM rehber")
        rows = cursor.fetchall()
    
        filtered_rows = []
        for row in rows:
            normalized_row = [
                self.remove_accents_and_lower(str(item)) for item in row[1:]  # ID'yi hariç tut
            ]
    
            # Telefon numaralarını normalleştir
            normalized_row[3] = self.normalize_phone_number(row[4])  # telefon1
            normalized_row[4] = self.normalize_phone_number(row[5])  # telefon2
    
            # Arama terimlerini ayır ve normalize et
            search_terms = [self.remove_accents_and_lower(term) for term in search_term.split()]
    
            # Her arama terimi için kontrol
            if all(any(self.term_matches(term, field) for field in normalized_row) for term in search_terms):
                filtered_rows.append(row)
    
        for index, row in enumerate(filtered_rows):
            color = '#f0f0f0' if index % 2 == 0 else '#ffffff'
            self.tree.insert("", "end", values=row[1:], tags=(f"row{index}",))
            self.tree.tag_configure(f"row{index}", background=color)
    
        conn.close()
    
    def clear_input_fields(self):
        # Tüm input alanlarını temizle
        self.trafo_merkezi.delete(0, tk.END)
        self.pax1.delete(0, tk.END)
        self.pax2.delete(0, tk.END)
        self.telefon1.delete(0, tk.END)
        self.telefon2.delete(0, tk.END)
        self.yetkili.delete(0, tk.END)
    
    def remove_accents(self, input_str):
        nfkd_form = unicodedata.normalize('NFKD', input_str)
        return u"".join([c for c in nfkd_form if not unicodedata.combining(c)])
    
    def remove_accents_and_lower(self, input_str):
        # Önce tüm karakterleri küçük harfe çevir
        input_str = input_str.lower()
        # Türkçe'ye özel 'I' ve 'İ' dönüşümü
        input_str = input_str.replace('ı', 'i').replace('İ', 'i')
        # Unicode normalizasyonu ve aksan kaldırma
        nfkd_form = unicodedata.normalize('NFKD', input_str)
        only_ascii = nfkd_form.encode('ASCII', 'ignore').decode('ASCII')
        return only_ascii
    
    def normalize_phone_number(self, phone_number):
        return re.sub(r'\D', '', str(phone_number))
    
    def term_matches(self, term, field):
        normalized_term = self.remove_accents_and_lower(term)
        normalized_field = self.remove_accents_and_lower(field)
    
        # Eğer terim bir telefon numarası gibi görünüyorsa
        if normalized_term.isdigit():
            normalized_term = self.normalize_phone_number(normalized_term)
            normalized_field = self.normalize_phone_number(normalized_field)
    
        return normalized_term in normalized_field
    def turkish_lower(self, s):
        return re.sub(r'İ', 'i', s.lower())
    
    def normalize_phone_number(self, phone_number):
        return re.sub(r'\D', '', phone_number)  # Remove all non-digit characters
    
    def update_clock(self):
        current_time = datetime.now().strftime("%H:%M:%S")
        self.clock_label.config(text=current_time)
        self.master.after(1000, self.update_clock)
    
    def item_selected(self, event):
        selected_item = self.tree.selection()
        if selected_item:
            item = self.tree.item(selected_item)
            record = item['values']
            self.clear_entries()
            self.trafo_merkezi.insert(0, record[0])
            self.pax1.insert(0, record[1])
            self.pax2.insert(0, record[2])
            self.telefon1.insert(0, record[3])
            self.telefon2.insert(0, record[4])
            self.yetkili.insert(0, record[5])
    
    def export_to_excel(self):
        conn = sqlite3.connect("rehber.db")
        df = pd.read_sql_query("SELECT * FROM rehber", conn)
        conn.close()
    
        file_path = filedialog.asksaveasfilename(defaultextension=".xlsx", filetypes=[("Excel files", "*.xlsx")])
        if file_path:
            with pd.ExcelWriter(file_path, engine='openpyxl') as writer:
                df.to_excel(writer, index=False, sheet_name='Rehber')
    
                workbook = writer.book
                sheet = workbook['Rehber']
    
                for column in sheet.columns:
                    max_length = 0
                    column_letter = column[0].column_letter
                    for cell in column:
                        try:
                            if cell.value and len(str(cell.value)) > max_length:
                                max_length = len(cell.value)
                        except:
                            pass
                    adjusted_width = (max_length + 2)
                    sheet.column_dimensions[column_letter].width = adjusted_width
    
            messagebox.showinfo("Başarılı", f"Veriler başarıyla {file_path} dosyasına aktarıldı.")
    
    def update_records(self):
        self.load_data()
        messagebox.showinfo("Başarılı", "Rehber güncellendi.")
    

    if name == "main": root = tk.Tk() app = RehberUygulamasi(root) root.mainloop()

    Bu benim rehber kodum kullanıcılar isim değişikliği yapmak isterse şifre istesin

  2. Assistant

    Eğer kullanıcılar isim değişikliği yapmak istediğinde bir şifre istemek istiyorsanız, "Düzenle" (edit_record) fonksiyonunun başına şifre doğrulaması ekleyebilirsiniz. Böyle bir doğrulama işlemi için, bir açılır pencere kullanarak kullanıcıdan şifre girmesi istenir. Aşağıda örnek bir şifre kontrolü eklenmiş olan edit_record fonksiyonunu bulabilirsiniz:

    def edit_record(self):
        # Şifre doğrulama penceresi
        def check_password():
            entered_password = pw_entry.get()
            if entered_password == "sifre123":  # Doğru şifreyi belirleyin
                pw_window.destroy()
                continue_editing()
            else:
                messagebox.showwarning("Yanlış Şifre", "Yanlış şifre girdiniz!")
        
        # Düzenleme işlemi devam ettirilir
        def continue_editing():
            selected_item = self.tree.selection()
            if not selected_item:
                messagebox.showwarning("Uyarı", "Lütfen düzenlenecek bir kayıt seçin.")
                return
    
            old_values = self.tree.item(selected_item)['values']
            new_values = (
                self.trafo_merkezi.get(),
                self.pax1.get(),
                self.pax2.get(),
                self.telefon1.get(),
                self.telefon2.get(),
                self.yetkili.get(),
                old_values[0]
            )
    
            conn = sqlite3.connect("rehber.db")
            cursor = conn.cursor()
            cursor.execute(
                "UPDATE rehber SET trafo_merkezi=?, pax1=?, pax2=?, telefon1=?, telefon2=?, yetkili=? WHERE trafo_merkezi=?",
                new_values)
            conn.commit()
            conn.close()
    
            self.add_log("Düzenleme", old_values[0], old_values, new_values[:-1])
    
            self.load_data()
            self.clear_entries()
        
        # Şifre penceresi oluştur
        pw_window = tk.Toplevel(self.master)
        pw_window.title("Şifre Girişi")
        pw_window.geometry("300x100")
        ttk.Label(pw_window, text="Şifre:").pack(pady=5)
        pw_entry = ttk.Entry(pw_window, show="*")
        pw_entry.pack(pady=5)
        ttk.Button(pw_window, text="Onayla", command=check_password).pack(pady=5)
    
        # Ana pencerenin etkileşimini şifre penceresi kapanana kadar engelle
        pw_window.grab_set()
        pw_window.transient(self.master)
    

    Bu örnekte, isim değişikliğinde kullanıcıdan bir şifre isteniyor. Şifre sifre123 olarak ayarlandı; isterseniz bunu başka bir şifreyle değiştirebilirsiniz. Eğer kullanıcı doğru şifreyi girerse, düzenleme işlemi devam ediyor. Yanlış şifre durumunda bir uyarı mesajı gösteriliyor.

  3. User

    kullanıcı sadece isimde değişiklik yapıyorsa şifre istesin diğer işlemlerde istemesin

  4. Assistant

    Bunu gerçekleştirmek için, sadece kullanıcı "Trafo Merkezi" alanında bir değişiklik yaparsa şifre isteyecek şekilde edit_record fonksiyonunu güncelleyebiliriz. Aşağıda, bu kontrolü gerçekleştiren bir yaklaşım verilmiştir:

    def edit_record(self):
        selected_item = self.tree.selection()
        if not selected_item:
            messagebox.showwarning("Uyarı", "Lütfen düzenlenecek bir kayıt seçin.")
            return
    
        old_values = self.tree.item(selected_item)['values']
    
        # Yeni ve eski "Trafo Merkezi" değerlerini karşılaştır
        trafo_merkezi_degisiyor_mu = old_values[0] != self.trafo_merkezi.get()
        
        new_values = (
            self.trafo_merkezi.get(),
            self.pax1.get(),
            self.pax2.get(),
            self.telefon1.get(),
            self.telefon2.get(),
            self.yetkili.get(),
            old_values[0]
        )
    
        def continue_editing():
            # Veritabanıyla bağlantı kurarak düzenleme işlemini yap
            conn = sqlite3.connect("rehber.db")
            cursor = conn.cursor()
            cursor.execute(
                "UPDATE rehber SET trafo_merkezi=?, pax1=?, pax2=?, telefon1=?, telefon2=?, yetkili=? WHERE trafo_merkezi=?",
                new_values)
            conn.commit()
            conn.close()
    
            self.add_log("Düzenleme", old_values[0], old_values, new_values[:-1])
    
            self.load_data()
            self.clear_entries()
    
        # Şifre kontrolü sadece "Trafo Merkezi" değişiyorsa yapılır
        if trafo_merkezi_degisiyor_mu:
            def check_password():
                entered_password = pw_entry.get()
                if entered_password == "sifre123":  # Doğru şifreyi belirleyin
                    pw_window.destroy()
                    continue_editing()
                else:
                    messagebox.showwarning("Yanlış Şifre", "Yanlış şifre girdiniz!")
            
            pw_window = tk.Toplevel(self.master)
            pw_window.title("Şifre Girişi")
            pw_window.geometry("300x100")
            ttk.Label(pw_window, text="Şifre:").pack(pady=5)
            pw_entry = ttk.Entry(pw_window, show="*")
            pw_entry.pack(pady=5)
            ttk.Button(pw_window, text="Onayla", command=check_password).pack(pady=5)
    
            pw_window.grab_set()
            pw_window.transient(self.master)
        else:
            continue_editing()
    

    Bu kod, kullanıcı "Trafo Merkezi" alanında değişiklik yapmışsa şifre penceresini açar ve doğru şifreyi girene kadar düzenleme işlemine devam etmez. Eğer sadece diğer alanlar değişmişse, doğrudan düzenleme işlemi yapılır.