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

ti incollo il codice del mio programma, cosi puoi aiutarmi ad aggiundere/rimuovere…

  1. User

    ti incollo il codice del mio programma, cosi puoi aiutarmi ad aggiundere/rimuovere funzionalita

  2. Assistant

    Certo! Incolla qui il tuo codice e fammi sapere quali funzionalità vorresti aggiungere o rimuovere. Sarò felice di aiutarti!

  3. User

    import sys import sqlite3 from datetime import datetime, date, timedelta from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QListWidget, QPushButton, QLabel, QLineEdit, QFormLayout, QDateEdit, QFileDialog, QMessageBox, QTabWidget, QTextEdit, QSpinBox, QDialog, QDialogButtonBox, QSystemTrayIcon, QMenu) from PyQt6.QtCore import Qt, QDate, QTimer from PyQt6.QtGui import QPixmap, QIcon from PIL import Image import io from reportlab.lib.pagesizes import letter from reportlab.pdfgen import canvas import pandas as pd import csv from openpyxl import Workbook

    def adapt_date(val): return val.isoformat()

    def convert_date(val): return date.fromisoformat(val.decode())

    sqlite3.register_adapter(date, adapt_date) sqlite3.register_converter("DATE", convert_date)

    class NotificationDialog(QDialog): def init(self, parent=None): super().init(parent) self.setWindowTitle("Impostazioni Notifiche") layout = QFormLayout(self) self.days_spinbox = QSpinBox() self.days_spinbox.setRange(1, 365) self.days_spinbox.setValue(30) layout.addRow("Giorni di anticipo per le notifiche:", self.days_spinbox) buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel) buttons.accepted.connect(self.accept) buttons.rejected.connect(self.reject) layout.addWidget(buttons)

    class ValveManager(QMainWindow): def init(self): super().init() self.setWindowTitle("Gestione Valvole di Sicurezza") self.setGeometry(100, 100, 1000, 600) self.setWindowIcon(QIcon('valve_icon.png'))

        self.init_db()
        self.init_ui()
        self.init_tray()
    
        self.notification_days = 30
        self.check_revisions()
    
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.check_revisions)
        self.timer.start(86400000)  # Controlla ogni 24 ore
    
    def init_db(self):
        self.conn = sqlite3.connect('valves.db', detect_types=sqlite3.PARSE_DECLTYPES)
        self.cursor = self.conn.cursor()
        self.cursor.execute('''CREATE TABLE IF NOT EXISTS valves
                            (id INTEGER PRIMARY KEY,
                             type TEXT,
                             location TEXT,
                             installation_date DATE,
                             last_revision_date DATE,
                             next_revision_date DATE,
                             image BLOB)''')
        self.conn.commit()
    
    def init_ui(self):
        main_layout = QHBoxLayout()
    
        list_layout = QVBoxLayout()
        self.valve_list = QListWidget()
        self.valve_list.itemClicked.connect(self.show_valve_details)
        list_layout.addWidget(self.valve_list)
    
        add_button = QPushButton("Prepara Nuova Valvola")
        add_button.clicked.connect(self.add_new_valve)
        list_layout.addWidget(add_button)
    
        delete_button = QPushButton("Elimina Valvola")
        delete_button.clicked.connect(self.delete_valve)
        list_layout.addWidget(delete_button)
    
        main_layout.addLayout(list_layout, 1)
    
        tab_widget = QTabWidget()
        
        details_widget = QWidget()
        form_layout = QFormLayout(details_widget)
        self.type_input = QLineEdit()
        self.location_input = QLineEdit()
        self.installation_date_input = QDateEdit()
        self.last_revision_date_input = QDateEdit()
        self.next_revision_date_input = QDateEdit()
        self.image_label = QLabel()
        self.image_label.setFixedSize(200, 200)
        self.image_label.setScaledContents(True)
    
        form_layout.addRow("Tipo:", self.type_input)
        form_layout.addRow("Posizione:", self.location_input)
        form_layout.addRow("Data installazione:", self.installation_date_input)
        form_layout.addRow("Ultima revisione:", self.last_revision_date_input)
        form_layout.addRow("Prossima revisione:", self.next_revision_date_input)
        form_layout.addRow("Immagine:", self.image_label)
    
        button_layout = QHBoxLayout()
        save_button = QPushButton("Salva modifiche")
        save_button.clicked.connect(self.save_valve)
        add_valve_button = QPushButton("Aggiungi Valvola")
        add_valve_button.clicked.connect(self.add_valve)
        add_image_button = QPushButton("Aggiungi Immagine")
        add_image_button.clicked.connect(self.add_image)
        button_layout.addWidget(save_button)
        button_layout.addWidget(add_valve_button)
        button_layout.addWidget(add_image_button)
    
        form_layout.addRow(button_layout)
    
        tab_widget.addTab(details_widget, "Dettagli Valvola")
    
        report_widget = QWidget()
        report_layout = QVBoxLayout(report_widget)
        self.report_text = QTextEdit()
        self.report_text.setReadOnly(True)
        report_layout.addWidget(self.report_text)
        generate_report_button = QPushButton("Genera Report")
        generate_report_button.clicked.connect(self.generate_report)
        report_layout.addWidget(generate_report_button)
    
        tab_widget.addTab(report_widget, "Report")
    
        main_layout.addWidget(tab_widget, 2)
    
        central_widget = QWidget()
        central_widget.setLayout(main_layout)
        self.setCentralWidget(central_widget)
    
        self.load_valves()
    
    def init_tray(self):
        self.tray_icon = QSystemTrayIcon(self)
        self.tray_icon.setIcon(QIcon('valve_icon.png'))
        
        tray_menu = QMenu()
        show_action = tray_menu.addAction("Mostra")
        show_action.triggered.connect(self.show)
        quit_action = tray_menu.addAction("Esci")
        quit_action.triggered.connect(QApplication.quit)
        
        self.tray_icon.setContextMenu(tray_menu)
        self.tray_icon.show()
    
    def load_valves(self):
        self.valve_list.clear()
        self.cursor.execute("SELECT id, type, location FROM valves")
        for row in self.cursor.fetchall():
            self.valve_list.addItem(f"{row[0]}: {row[1]} - {row[2]}")
    
    def show_valve_details(self, item):
        valve_id = int(item.text().split(':')[0])
        self.cursor.execute("SELECT * FROM valves WHERE id=?", (valve_id,))
        valve = self.cursor.fetchone()
        if valve:
            self.type_input.setText(valve[1])
            self.location_input.setText(valve[2])
            self.installation_date_input.setDate(QDate(valve[3]))
            self.last_revision_date_input.setDate(QDate(valve[4]))
            self.next_revision_date_input.setDate(QDate(valve[5]))
            if valve[6]:
                pixmap = QPixmap()
                pixmap.loadFromData(valve[6])
                self.image_label.setPixmap(pixmap)
            else:
                self.image_label.clear()
    
    def save_valve(self):
        current_item = self.valve_list.currentItem()
        if not current_item:
            QMessageBox.warning(self, "Nessuna valvola selezionata", "Seleziona una valvola da aggiornare.")
            return
    
        valve_id = int(current_item.text().split(':')[0])
        type_ = self.type_input.text()
        location = self.location_input.text()
        installation_date = self.installation_date_input.date().toPyDate()
        last_revision_date = self.last_revision_date_input.date().toPyDate()
        next_revision_date = self.next_revision_date_input.date().toPyDate()
    
        # Controlla se i dati sono stati modificati
        self.cursor.execute("SELECT * FROM valves WHERE id=?", (valve_id,))
        existing_valve = self.cursor.fetchone()
        if existing_valve:
            if (existing_valve[1] != type_ or
                existing_valve[2] != location or
                existing_valve[3] != installation_date or
                existing_valve[4] != last_revision_date or
                existing_valve[5] != next_revision_date):
                
                reply = QMessageBox.question(self, 'Conferma modifica',
                                             'Sei sicuro di voler sovrascrivere i dati esistenti?',
                                             QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
                                             QMessageBox.StandardButton.No)
                if reply == QMessageBox.StandardButton.No:
                    return
    
            self.cursor.execute('''UPDATE valves SET type=?, location=?, installation_date=?, 
                                   last_revision_date=?, next_revision_date=? WHERE id=?''',
                                (type_, location, installation_date, last_revision_date, 
                                 next_revision_date, valve_id))
            self.conn.commit()
            self.load_valves()
            QMessageBox.information(self, "Aggiornamento completato", "I dati della valvola sono stati aggiornati con successo.")
        else:
            QMessageBox.warning(self, "Errore", "La valvola selezionata non esiste più nel database.")
    
    def add_valve(self):
        type_ = self.type_input.text()
        location = self.location_input.text()
        installation_date = self.installation_date_input.date().toPyDate()
        last_revision_date = self.last_revision_date_input.date().toPyDate()
        next_revision_date = self.next_revision_date_input.date().toPyDate()
    
        if not type_ or not location:
            QMessageBox.warning(self, "Dati mancanti", "Inserisci almeno il tipo e la posizione della valvola.")
            return
    
        self.cursor.execute('''INSERT INTO valves (type, location, installation_date, 
                               last_revision_date, next_revision_date) 
                               VALUES (?, ?, ?, ?, ?)''',
                            (type_, location, installation_date, last_revision_date, 
                             next_revision_date))
        self.conn.commit()
        self.load_valves()
        QMessageBox.information(self, "Aggiunta completata", "La nuova valvola è stata aggiunta con successo.")
        self.add_new_valve()  # Pulisce i campi per una nuova inserzione
    
    def add_image(self):
        current_item = self.valve_list.currentItem()
        if not current_item:
            QMessageBox.warning(self, "Nessuna valvola selezionata", "Seleziona una valvola per aggiungere un'immagine.")
            return
    
        file_name, _ = QFileDialog.getOpenFileName(self, "Seleziona un'immagine", "", "Image Files (*.png *.jpg *.bmp)")
        if file_name:
            with Image.open(file_name) as img:
                img = img.resize((200, 200))
                buf = io.BytesIO()
                img.save(buf, format='PNG')
                image_data = buf.getvalue()
    
            valve_id = int(current_item.text().split(':')[0])
            self.cursor.execute("UPDATE valves SET image=? WHERE id=?", (image_data, valve_id))
            self.conn.commit()
    
            pixmap = QPixmap(file_name)
            self.image_label.setPixmap(pixmap)
    
    def check_revisions(self):
        today = date.today()
        future_date = today + timedelta(days=self.notification_days)
        self.cursor.execute("SELECT id, type, location, next_revision_date FROM valves WHERE next_revision_date <= ?", 
                            (future_date,))
        due_valves = self.cursor.fetchall()
        if due_valves:
            message = f"Le seguenti valvole necessitano di revisione entro {self.notification_days} giorni:\n\n"
            for valve in due_valves:
                message += f"ID: {valve[0]}, Tipo: {valve[1]}, Posizione: {valve[2]}, Data revisione: {valve[3]}\n"
            self.tray_icon.showMessage("Revisioni in scadenza", message, QSystemTrayIcon.MessageIcon.Warning)
    
    def add_new_valve(self):
        self.valve_list.clearSelection()
        self.type_input.clear()
        self.location_input.clear()
        self.installation_date_input.setDate(QDate.currentDate())
        self.last_revision_date_input.setDate(QDate.currentDate())
        self.next_revision_date_input.setDate(QDate.currentDate())
        self.image_label.clear()
    
    def delete_valve(self):
        current_item = self.valve_list.currentItem()
        if current_item:
            valve_id = int(current_item.text().split(':')[0])
            reply = QMessageBox.question(self, 'Conferma eliminazione',
                                         'Sei sicuro di voler eliminare questa valvola?',
                                         QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
                                         QMessageBox.StandardButton.No)
            if reply == QMessageBox.StandardButton.Yes:
                self.cursor.execute("DELETE FROM valves WHERE id=?", (valve_id,))
                self.conn.commit()
                self.load_valves()
                self.add_new_valve()
    
    def generate_report(self):
        self.cursor.execute("SELECT * FROM valves")
        valves = self.cursor.fetchall()
        report = "Report Valvole di Sicurezza\n\n"
        for valve in valves:
            report += f"ID: {valve[0]}\n"
            report += f"Tipo: {valve[1]}\n"
            report += f"Posizione: {valve[2]}\n"
            report += f"Data installazione: {valve[3]}\n"
            report += f"Ultima revisione: {valve[4]}\n"
            report += f"Prossima revisione: {valve[5]}\n"
            report += "-" * 30 + "\n"
        self.report_text.setText(report)
    
        export_layout = QHBoxLayout()
        export_pdf_button = QPushButton("Esporta in PDF")
        export_pdf_button.clicked.connect(self.export_to_pdf)
        export_csv_button = QPushButton("Esporta in CSV")
        export_csv_button.clicked.connect(self.export_to_csv)
        export_excel_button = QPushButton("Esporta in Excel")
        export_excel_button.clicked.connect(self.export_to_excel)
        export_layout.addWidget(export_pdf_button)
        export_layout.addWidget(export_csv_button)
        export_layout.addWidget(export_excel_button)
        
        self.centralWidget().findChild(QTabWidget).widget(1).layout().addLayout(export_layout)
    
    def export_to_pdf(self):
        file_name, _ = QFileDialog.getSaveFileName(self, "Salva PDF", "", "PDF Files (*.pdf)")
        if file_name:
            if not file_name.endswith('.pdf'):
                file_name += '.pdf'
            
            c = canvas.Canvas(file_name, pagesize=letter)
            width, height = letter
            c.setFont("Helvetica", 12)
            
            y = height - 40
            c.drawString(30, y, "Report Valvole di Sicurezza")
            y -= 20
            
            self.cursor.execute("SELECT * FROM valves")
            valves = self.cursor.fetchall()
            
            for valve in valves:
                if y < 50:  # New page if not enough space
                    c.showPage()
                    c.setFont("Helvetica", 12)
                    y = height - 40
                
                c.drawString(30, y, f"ID: {valve[0]}")
                y -= 15
                c.drawString(30, y, f"Tipo: {valve[1]}")
                y -= 15
                c.drawString(30, y, f"Posizione: {valve[2]}")
                y -= 15
                c.drawString(30, y, f"Data installazione: {valve[3]}")
                y -= 15
                c.drawString(30, y, f"Ultima revisione: {valve[4]}")
                y -= 15
                c.drawString(30, y, f"Prossima revisione: {valve[5]}")
                y -= 20
            
            c.save()
            QMessageBox.information(self, "Esportazione completata", "Il report è stato esportato in PDF con successo.")
    
    def export_to_csv(self):
        file_name, _ = QFileDialog.getSaveFileName(self, "Salva CSV", "", "CSV Files (*.csv)")
        if file_name:
            if not file_name.endswith('.csv'):
                file_name += '.csv'
            
            self.cursor.execute("SELECT * FROM valves")
            valves = self.cursor.fetchall()
            
            df = pd.DataFrame(valves, columns=['ID', 'Tipo', 'Posizione', 'Data installazione', 'Ultima revisione', 'Prossima revisione', 'Immagine'])
            df = df.drop('Immagine', axis=1)  # Rimuovi la colonna dell'immagine
            df.to_csv(file_name, index=False, quoting=csv.QUOTE_NONNUMERIC)
            
            QMessageBox.information(self, "Esportazione completata", "Il report è stato esportato in CSV con successo.")
    
    def export_to_excel(self):
        file_name, _ = QFileDialog.getSaveFileName(self, "Salva Excel", "", "Excel Files (*.xlsx)")
        if file_name:
            if not file_name.endswith('.xlsx'):
                file_name += '.xlsx'
            
            wb = Workbook()
            ws = wb.active
            ws.title = "Report Valvole di Sicurezza"
            
            # Aggiungi intestazioni
            headers = ['ID', 'Tipo', 'Posizione', 'Data installazione', 'Ultima revisione', 'Prossima revisione']
            ws.append(headers)
            
            # Aggiungi dati
            self.cursor.execute("SELECT id, type, location, installation_date, last_revision_date, next_revision_date FROM valves")
            valves = self.cursor.fetchall()
            for valve in valves:
                ws.append(valve)
            
            # Adatta la larghezza delle colonne
            for column in ws.columns:
                max_length = 0
                column_letter = column[0].column_letter
                for cell in column:
                    try:
                        if len(str(cell.value)) > max_length:
                            max_length = len(cell.value)
                    except:
                        pass
                adjusted_width = (max_length + 2)
                ws.column_dimensions[column_letter].width = adjusted_width
            
            wb.save(file_name)
            QMessageBox.information(self, "Esportazione completata", "Il report è stato esportato in Excel con successo.")
    
    def closeEvent(self, event):
        event.ignore()
        self.hide()
        self.tray_icon.showMessage("Applicazione minimizzata", "L'applicazione è ancora in esecuzione nel system tray.")
    

    if name == "main": app = QApplication(sys.argv) window = ValveManager() window.show() sys.exit(app.exec())

  4. Assistant

    Grazie per aver condiviso il tuo codice. Il programma è piuttosto completo e ben organizzato. Di seguito, ti fornisco una panoramica su come puoi aggiungere o rimuovere funzionalità specifiche. Non esitare a chiedere se hai necessità più specifiche o se qualcosa non è chiaro!

    Aggiungere funzionalità

    1. Aggiungere filtro di ricerca per le valvole

    Aggiungere la possibilità di filtrare l'elenco delle valvole in base a specifici criteri (es. tipo, posizione, data di installazione) può essere molto utile.

    Ecco come aggiungere una barra di ricerca semplice:

    1. Modifica nella funzione init_ui:

      def init_ui(self):
          main_layout = QHBoxLayout()
      
          # Sezione laterale con lista e pulsanti
          list_layout = QVBoxLayout()
      
          # Aggiungi la barra di ricerca
          self.search_input = QLineEdit()
          self.search_input.setPlaceholderText("Cerca per tipo o posizione...")
          self.search_input.textChanged.connect(self.filter_valves)
          list_layout.addWidget(self.search_input)
      
          self.valve_list = QListWidget()
          self.valve_list.itemClicked.connect(self.show_valve_details)
          list_layout.addWidget(self.valve_list)
      
          add_button = QPushButton("Prepara Nuova Valvola")
          add_button.clicked.connect(self.add_new_valve)
          list_layout.addWidget(add_button)
      
          delete_button = QPushButton("Elimina Valvola")
          delete_button.clicked.connect(self.delete_valve)
          list_layout.addWidget(delete_button)
      
    2. Aggiungi una nuova funzione filter_valves al tuo codice:

      def filter_valves(self, text):
          filter_text = text.lower()
          self.cursor.execute("SELECT id, type, location FROM valves")
          all_valves = self.cursor.fetchall()
          self.valve_list.clear()
          for valve in all_valves:
              if filter_text in valve[1].lower() or filter_text in valve[2].lower():
                  self.valve_list.addItem(f"{valve[0]}: {valve[1]} - {valve[2]}")
      

    2. Aggiungere una funzione per modificare l'immagine di una valvola esistente

    Nell'attuale implementazione, l'immagine viene aggiunta solo quando si crea una nuova valvola. Puoi creare una funzionalità per sostituire l'immagine di una valvola esistente.

    1. Aggiungi un nuovo pulsante per modificare l'immagine:

      add_image_button = QPushButton("Aggiungi Immagine")
      add_image_button.clicked.connect(self.add_image)
      
      update_image_button = QPushButton("Aggiorna Immagine")
      update_image_button.clicked.connect(self.update_image)
      
      button_layout.addWidget(save_button)
      button_layout.addWidget(add_valve_button)
      button_layout.addWidget(add_image_button)
      button_layout.addWidget(update_image_button)
      
    2. Aggiungi la funzione update_image:

      def update_image(self):
          current_item = self.valve_list.currentItem()
          if not current_item:
              QMessageBox.warning(self, "Nessuna valvola selezionata", "Seleziona una valvola per aggiornare l'immagine.")
              return
      
          file_name, _ = QFileDialog.getOpenFileName(self, "Seleziona un'immagine", "", "Image Files (*.png *.jpg *.bmp)")
          if file_name:
              with Image.open(file_name) as img:
                  img = img.resize((200, 200))
                  buf = io.BytesIO()
                  img.save(buf, format='PNG')
                  image_data = buf.getvalue()
      
              valve_id = int(current_item.text().split(':')[0])
              self.cursor.execute("UPDATE valves SET image=? WHERE id=?", (image_data, valve_id))
              self.conn.commit()
      
              pixmap = QPixmap(file_name)
              self.image_label.setPixmap(pixmap)
              QMessageBox.information(self, "Immagine aggiornata", "L'immagine della valvola è stata aggiornata con successo.")
      

    Rimuovere funzionalità

    1. Rimuovere le funzionalità di esportazione a PDF/CSV/Excel

    Se desideri rimuovere le funzionalità di esportazione:

    1. Rimuovi le chiamate ai pulsanti di esportazione nella funzione generate_report:

      def generate_report(self):
          self.cursor.execute("SELECT * FROM valves")
          valves = self.cursor.fetchall()
          report = "Report Valvole di Sicurezza\n\n"
          for valve in valves:
              report += f"ID: {valve[0]}\n"
              report += f"Tipo: {valve[1]}\n"
              report += f"Posizione: {valve[2]}\n"
              report += f"Data installazione: {valve[3]}\n"
              report += f"Ultima revisione: {valve[4]}\n"
              report += f"Prossima revisione: {valve[5]}\n"
              report += "-" * 30 + "\n"
          self.report_text.setText(report)
      
          # Rimuovi i pulsanti di esportazione
          # export_layout = QHBoxLayout()
          # export_pdf_button = QPushButton("Esporta in PDF")
          # export_pdf_button.clicked.connect(self.export_to_pdf)
          # export_csv_button = QPushButton("Esporta in CSV")
          # export_csv_button.clicked.connect(self.export_to_csv)
          # export_excel_button = QPushButton("Esporta in Excel")
          # export_excel_button.clicked.connect(self.export_to_excel)
          # export_layout.addWidget(export_pdf_button)
          # export_layout.addWidget(export_csv_button)
          # export_layout.addWidget(export_excel_button)
          
          # self.centralWidget().findChild(QTabWidget).widget(1).layout().addLayout(export_layout)
      
    2. Elimina le funzioni di esportazione:

      def export_to_pdf(self):
          pass
      
      def export_to_csv(self):
          pass
      
      def export_to_excel(self):
          pass
      

    Questa è una breve guida su come modificare il tuo programma per aggiungere o rimuovere funzionalità. Se hai altre richieste specifiche o domande su come implementare altre funzionalità, fammelo sapere!