def add_defaut_day(cls, start_day):
"""
Récupère les donnée de gestion des équipes
:return: Une liste
"""
equipe_matin = 1
conducteur_matin = "Fred"
aide_matin = "Jean-Luc"
heure_matin = FIN_PROD_MATIN_VENDREDI - DEBUT_PROD_MATIN if is_vendredi(start_day) else FIN_PROD_MATIN - DEBUT_PROD_MATIN
equipe_soir = 1
conducteur_soir = "Fred2"
aide_soir = "Cyril"
heure_soir = FIN_PROD_SOIR_VENDREDI - FIN_PROD_MATIN_VENDREDI if is_vendredi(start_day) else FIN_PROD_SOIR - FIN_PROD_MATIN
ferier = 0
query = "INSERT INTO mondon_equipe VALUES(?,?,?,?,?,?,?,?,?,?,?)".format(start_day,
DEBUT_PROD_MATIN,
equipe_matin,
conducteur_matin,
aide_matin,
heure_matin,
equipe_soir,
conducteur_soir,
aide_soir,
heure_soir, ferier)
try:
pass
except sqlite3.IntegrityError as e:
logger.log("DATABASE", "(Ignorée) IntegrityError: {}".format(e))
pass
def create_database_connection(cls):
"""
Crée une nouvelle connexion à la base de données.
:return: Une nouvelle connexion à la base de données
"""
logger.log("DATABASE", "Connection à la base de données {}".format(DATABASE_LOCATION))
conn = sqlite3.connect(DATABASE_LOCATION)
return conn
def _handle_size_main_window_changed(self):
try:
self.on_size_main_window_changed()
except Exception as e:
logger.log(
type(self),
"Erreur pendant l'exécution de `on_size_main_window_changed`: {}"
.format(e))
def create_event_prod(cls, start, end, p_type, info=None, ensemble=None):
query = "INSERT INTO mondon_event (type,start,end,info, ensemble) " \
"VALUES (?, ?, ?, ?, ?)".format(p_type, start, end, info, ensemble)
try:
cls.run_query(query, (p_type, start, end, info, ensemble))
except sqlite3.IntegrityError as e:
logger.log("DATABASE", "(Ignorée) IntegrityError: {}".format(e))
pass
def delete_plan_prod(cls, p_id):
query = "DELETE FROM mondon_plan_prod " \
"WHERE p_id = ? ".format(p_id)
try:
cls.run_query(query, (p_id,))
except sqlite3.IntegrityError as e:
logger.log("DATABASE", "(Ignorée) IntegrityError: {}".format(e))
pass
def _handle_filter_changed(self):
try:
self.on_filter_changed()
except Exception as e:
logger.log(
type(self),
"Erreur pendant l'exécution de `on_filter_changed`: {}".format(
e))
def _handle_settings_chart_changed(self):
try:
self.on_settings_chart_changed()
except Exception as e:
logger.log(
type(self),
"Erreur pendant l'exécution de `on_data_stat_changed`: {}".
format(e))
def _handle_settings_changed(self, prev_live, prev_day_ago, prev_zoom):
try:
self.on_settings_changed(prev_live, prev_day_ago, prev_zoom)
except Exception as e:
logger.log(
type(self),
"Erreur pendant l'exécution de `on_settings_changed`: {}".
format(e))
def affiche_pdf(name_file):
import os
"""affiche le pdf créé, dans le visualiseur pdf par défaut de l'OS"""
if os.path.exists(name_file):
try:
# solution pour Windows
os.startfile(name_file)
except Exception as e:
from commun.lib.logger import logger
logger.log("RAPPORT", "Impossible d'ouvrir le fichier PDF : {}".format(e))
def __init__(self, parent=None):
super(ContentChart, self).__init__(parent=parent)
self.background_color = colors.color_blanc
self.color_data_métrage = [colors.color_gris_moyen, colors.color_gris_fonce, colors.color_vert_fonce]
self.color_data_temps = [colors.color_bleu, colors.color_rouge, colors.color_gris_fonce]
self.bars = []
self.hbox = QHBoxLayout()
try:
self.init_widget()
except:
logger.log("CHART_STAT", "Erreur de mise à jour lors de l'initialisation du chart")
def delete_raison_arret(cls, _id):
query = "DELETE FROM mondon_raison_arret WHERE id = ?"\
.format(id=_id)
try:
cls.run_query(query, (_id,))
except sqlite3.IntegrityError as e:
# IntegrityError veut dire que l'on essaye d'insérer une vitesse avec un timestamp
# qui existe déjà dans la base de données.
# Dans ce cas, on considère que cette valeur n'a pas besoin d'être insérée et on
# ignore l'exception.
logger.log("DATABASE", "(Ignorée) IntegrityError: {}".format(e))
pass
def create_plan_prod(cls, p_id, start, refente, bobine_papier, code_bobines_selected, longueur, tours, bobine_poly,
encrier_1, encrier_2, encrier_3, code_data_reglages):
query = "INSERT INTO mondon_plan_prod (refente,bobine_papier,start,p_id,code_bobines_selected," \
"longueur,tours,bobine_poly,encrier_1,encrier_2,encrier_3,code_data_reglages) " \
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)".format(refente, bobine_papier, start, p_id,
code_bobines_selected, longueur, tours,
bobine_poly, encrier_1, encrier_2, encrier_3,
code_data_reglages)
try:
cls.run_query(query, (refente, bobine_papier, start, p_id, code_bobines_selected, longueur, tours,
bobine_poly, encrier_1, encrier_2, encrier_3, code_data_reglages))
except sqlite3.IntegrityError as e:
logger.log("DATABASE", "(Ignorée) IntegrityError: {}".format(e))
pass
def create_arret(cls, start_arret, end_arret):
"""
Ajoute l'arrêt en base donnée
:param start_arret: Timestamp début de l'arrêt
:param end_arret: Timestamp fin de l'arrêt
"""
try:
cls.run_query("INSERT INTO mondon_arret VALUES (?, ?)", (start_arret, end_arret))
except sqlite3.IntegrityError as e:
# IntegrityError veut dire que l'on essaye d'insérer une vitesse avec un timestamp
# qui existe déjà dans la base de données.
# Dans ce cas, on considère que cette valeur n'a pas besoin d'être insérée et on
# ignore l'exception.
logger.log("DATABASE", "(Ignorée) IntegrityError: {}".format(e))
pass
def insert_jour_metrages(cls, ts_jour, metrage_matin, metrage_soir):
"""
Ajoute les metrages matin et soir d'un jour en base de donnee
:param ts_jour: timestamp du debut du jour renseigne
:param metrage_matin: la somme du metrage pour l'equipe du matin
:param metrage_soir: la somme du metrage pour l'equipe du soir
"""
try:
cls.run_query("INSERT INTO mondon_metrage VALUES (?, ?, ?)", (ts_jour, metrage_matin, metrage_soir))
except sqlite3.IntegrityError as e:
# IntegrityError veut dire que l'on essaye d'insérer une vitesse avec un timestamp
# qui existe déjà dans la base de données.
# Dans ce cas, on considère que cette valeur n'a pas besoin d'être insérée et on
# ignore l'exception.
logger.log("DATABASE", "(Ignorée) IntegrityError: {}".format(e))
pass
def create_raison_arret(cls, _id, start_arret, type_arret, raison_arret, primaire=0):
query = "INSERT INTO mondon_raison_arret VALUES (?, ?, ?, ?, ?)"\
.format(id=_id,
start_arret=start_arret,
type_arret=type_arret,
raison_arret=raison_arret,
prioritaire=primaire)
try:
cls.run_query(query, (_id, start_arret, type_arret, raison_arret, primaire))
except sqlite3.IntegrityError as e:
# IntegrityError veut dire que l'on essaye d'insérer une vitesse avec un timestamp
# qui existe déjà dans la base de données.
# Dans ce cas, on considère que cette valeur n'a pas besoin d'être insérée et on
# ignore l'exception.
logger.log("DATABASE", "(Ignorée) IntegrityError: {}".format(e))
pass
def update_plan_prod(cls, p_id, start, refente, bobine_papier, code_bobines_selected, longueur, tours, bobine_poly,
encrier_1, encrier_2, encrier_3, code_data_reglages):
query = "UPDATE mondon_plan_prod " \
"SET start = ?, refente = ?, bobine_papier = ?, code_bobines_selected = ?, longueur = ?, tours = ?," \
"bobine_poly = ?, encrier_1 = ?, encrier_2 = ?, encrier_3 = ?, code_data_reglages = ? WHERE p_id = ? " \
.format(start, refente, bobine_papier, code_bobines_selected, longueur, tours, bobine_poly, encrier_1,
encrier_2, encrier_3, code_data_reglages, p_id)
try:
cls.run_query(query, (start, refente, bobine_papier, code_bobines_selected, longueur, tours,
bobine_poly, encrier_1, encrier_2, encrier_3, code_data_reglages, p_id))
except sqlite3.IntegrityError as e:
# IntegrityError veut dire que l'on essaye d'insérer une vitesse avec un timestamp
# qui existe déjà dans la base de données.
# Dans ce cas, on considère que cette valeur n'a pas besoin d'être insérée et on
# ignore l'exception.
logger.log("DATABASE", "(Ignorée) IntegrityError: {}".format(e))
pass
def update_arret(cls, start_arret, end_arret):
"""
Met à jour un arret
:param start_arret: Début de l'arrêt (clé pour retrouver l'arret en base de donnée)
:param end_arret: Fin de l'arret
"""
query = "UPDATE mondon_arret " \
"SET end = ? " \
"WHERE start = ?" \
.format(end_arret, start_arret)
try:
cls.run_query(query, (end_arret, start_arret))
except sqlite3.IntegrityError as e:
# IntegrityError veut dire que l'on essaye d'insérer une vitesse avec un timestamp
# qui existe déjà dans la base de données.
# Dans ce cas, on considère que cette valeur n'a pas besoin d'être insérée et on
# ignore l'exception.
logger.log("DATABASE", "(Ignorée) IntegrityError: {}".format(e))
pass
def update_to_raison_primaire(cls, _id, primaire):
"""
Update une raison pour la rendre primaire
:param _id: L'id de la raison
:param primaire: 1 si la raison est primaire
"""
query = "UPDATE mondon_raison_arret " \
"SET primaire = ? " \
"WHERE id = ?" \
.format(primaire, _id)
try:
cls.run_query(query, (primaire, _id))
except sqlite3.IntegrityError as e:
# IntegrityError veut dire que l'on essaye d'insérer une vitesse avec un timestamp
# qui existe déjà dans la base de données.
# Dans ce cas, on considère que cette valeur n'a pas besoin d'être insérée et on
# ignore l'exception.
logger.log("DATABASE", "(Ignorée) IntegrityError: {}".format(e))
pass
def run_query(cls, query, args):
"""
Exécute une requête sur la base de données
:param query: Requête SQL à exécuter
:param args: Paramètre de la requête à exécuter
:return: Un array avec le résultat de la requête.
Retourne un tableau vide pour les CREATE et INSERT
"""
logger.log("DATABASE", "Requête: {} - Paramêtres: {}".format(query, args))
data = None
attempt = 0
conn = cls.create_database_connection()
while attempt < Database.MAX_ATTEMPT_ON_ERROR:
if attempt > 0:
sleep(Database.SLEEP_ON_ERROR_MS / 1000) # Pause entre 2 tentatives
logger.log("DATABASE", "(Tentative #{}) Requête: {} - Paramêtres: {}"
.format(attempt + 1, query, args))
try:
cursor = conn.cursor()
cursor.execute(query, args)
conn.commit()
data = cursor.fetchall()
break
except sqlite3.OperationalError as e:
# OperationalError veut généralement dire que la base de données est locked ou
# de manière générale qu'une erreur s'est produite lors de la lecture du fichier
# où la base de données est stockée.
logger.log("DATABASE", "OperationalError: {}".format(e))
attempt += 1
except sqlite3.DatabaseError as e:
if e.__class__.__name__ == "DatabaseError":
# DatabaseError veut généralement dire qu'une erreur grave s'est produite.
# En générale, cela veut dire que la base de données est corrompue et l'on ne
# peut pas faire grand chose. On essaye quand même de s'en sortir en recréant
# la connexion à la base de données.
logger.log("DATABASE", "DatabaseError: {}".format(e))
attempt += 1
conn = cls.create_database_connection()
# Si l'exception n'est pas directement une DatabaseError (ex: une sous class de
# DatabaseError comme IntegrityError), on abandonne directement.
else:
raise e
# Dans le cas où on a consommé tous les essais possible, on génère une erreur
if attempt >= Database.MAX_ATTEMPT_ON_ERROR:
raise Exception("Abandon de la requête {} avec les paramètres {}. Une erreur s'est"
"produite à chacun des {} essais"
.format(query, args, Database.MAX_ATTEMPT_ON_ERROR))
return data
def create_main_window(self):
if self.main_window:
focus_window(self.main_window)
else:
from production.ui.windows.main_window import MainWindow
logger.log("INITIALISATION", "Création de la Window")
self.main_window = MainWindow(self.on_close_main_window,
self.on_resize_main_window)
logger.log("INITIALISATION", "Configuration de la Window")
self.main_window.initialisation()
self.main_window.setWindowTitle("DUNE Production bobine")
self.main_window.resize(window_width, window_height)
self.main_window.setMinimumSize(window_width, window_height)
logger.log("INITIALISATION", "Affichage de MainWindow")
self.main_window.show()
from commun.lib.logger import logger
logger.log_app_start()
import sys
from PyQt5.QtGui import QIcon
mode = 'ui'
if len(sys.argv) > 1:
mode = sys.argv[1]
from production.ui.application import app
from production.stores.data_store_manager import data_store_manager
data_store_manager.refresh_data()
from commun.utils.update_data_metrage import update_data_metrage
update_data_metrage()
if mode == 'ui':
logger.log("INITIALISATION", "Définition de l'icone de l'application")
app.setWindowIcon(QIcon("commun/assets/icons/logo_dune_production.ico"))
from production.ui.application import app
app.create_popup_user()
if mode in ('-r', '--rapport', 'rapport'):
from production.ui.widgets.rapport.menu_rapport import RapportMenu
rapport_menu = RapportMenu()
rapport_menu.externat_get_pdf()
if mode == 'ui':
sys.exit(app.exec_())
def on_settings_chart_changed(self):
try:
self.init_widget()
except:
logger.log("CHART_STAT", "Erreur de mise à jour lors du changement de settings du chart")
def on_settings_stat_changed(self):
try:
self.on_loading(layout=self.hbox, gif_name="loader_white_green", set_text=True, size=40)
except:
logger.log("CHART_STAT", "Erreur d'affichage chargement")
def on_data_stat_changed(self):
try:
self.init_widget()
except:
logger.log("CHART_STAT", "Erreur de mise à jour lors du changement de data chart")
def on_settings_stat_changed(self):
clear_layout(self.hbox)
try:
self.init_widget()
except:
logger.log("CHART_STAT", "Erreur de mise à jour lors du chargement des settings du chart")
