APP test

config.yaml

@@ -0,0 +1,87 @@
+data:
+  vehicules:
+    path: 20230731_GTP2023_crea_futur_EBP_AFF_PARAM_table_vehicules.xlsx
+    sheet_name: "type contrats"
+    columns: "B:C"
+    rows: 8
+    skiprows: Null
+  societes:
+    path: 20230731_GTP2023_sec_grh_pay_bd_gtp_v04_PARAM_table_services_Groupe1.xlsx
+    sheet_name: "SERVICES"
+    columns: "A"
+    rows: Null
+    skiprows: Null
+  contrats:
+    path: 20230731_GTP2023_sec_grh_pay_bd_gtp_v04_PARAM_table_contrats.xlsx
+    sheet_name: "type contrats"
+    columns: "B:C"
+    rows: Null
+    skiprows: Null
+  feries:
+    path: 20230731_GTP2023_sec_grh_pay_bd_gtp_v04_PARAM_table_feries_rtt.xlsx
+    sheet_name: "Calcul RTT"
+    columns: "E"
+    rows: Null
+    skiprows: Null
+  intervenants:
+    path: 20230823_GTP2023_EBP_MNR2021G_exp_intervenant_table_v02_00.xlsx
+    sheet_name: "Sheet"
+    columns: "A,D:F,M,N,Y,AN"
+    rows: Null
+    skiprows: Null
+
+  MNR_Affaire:
+    path: 20230823_GTP2023_EBP_MNR2021G_AFF_liste.xlsx
+    sheet_name: "Sheet"
+    columns: "A,D,E,J,K"
+    rows: Null
+    skiprows: Null
+  STM_Affaire:
+    path: 20230823_GTP2023_EBP_STM2021G_AFF_liste.xlsx
+    sheet_name: "Sheet"
+    columns: "A,D,E,J,K"
+    rows: Null
+    skiprows: Null
+  VALM_Affaire:
+    path: 20230823_GTP2023_EBP_VALM2019_AFF_liste.xlsx
+    sheet_name: "Sheet"
+    columns: "A,D,E,J,K"
+    rows: Null
+    skiprows: Null
+  MNR_Client:
+    path: 20230828_GTP2023_EBP_MNR2021G_CLI_liste_v02.xlsx
+    sheet_name: "Sheet"
+    columns: "A,B,E,Q:T"
+    rows: Null
+    skiprows: Null
+  STM_Client:
+    path: 20230828_GTP2023_EBP_STM2021G_CLI_liste_v02.xlsx
+    sheet_name: "Sheet"
+    columns: "A,W,E,Q:T"
+    rows: Null
+    skiprows: Null
+  VALM_Client:
+    path: 20230828_GTP2023_EBP_VALM2019_CLI_liste_v02.xlsx
+    sheet_name: "Sheet"
+    columns: "A,B,C,Q:T"
+    rows: Null
+    skiprows: Null
+
+  supplements:
+    path: 20230731_GTP2023_sec_grh_pay_bd_gtp_v04_PARAM_table_suppl_remu.xlsx
+    sheet_name: "Feuil1"
+    columns: "D"
+    rows: 8
+    skiprows: 3
+  absences:
+    path: 20230731_GTP2023_sec_grh_pay_bd_gtp_v04_PARAM_table_motif_absences_input.xlsx
+    sheet_name: "Feuil1"
+    columns: "D:E"
+    rows: 10
+    skiprows: 2
+  arrets:
+    path: bareme_arrets.xlsx
+    sheet_name: "Feuille1"
+    columns: "H:L"
+    rows: null
+    skiprows: null

const.py

@@ -0,0 +1,5 @@
+import os
+
+root_path = os.path.abspath(os.path.dirname(__file__))
+while not os.path.isfile(os.path.join(root_path, '.gitignore')):
+    root_path = os.path.dirname(root_path)

data/cli_dropbox.py

@@ -0,0 +1,214 @@
+import os
+import pathlib
+from typing import List
+import dropbox
+from dropbox.exceptions import AuthError
+from dropbox import DropboxOAuth2FlowNoRedirect
+
+import pandas as pd
+import streamlit as st
+from dotenv import load_dotenv
+
+load_dotenv()
+DROPBOX_ACCESS_TOKEN = os.environ.get("DROPBOX_ACCESS_TOKEN")
+DROPBOX_REFRESH_TOKEN = os.environ.get("DROPBOX_REFRESH_TOKEN")
+DROPBOX_APP_KEY = os.environ.get("DROPBOX_APP_KEY")
+DROPBOX_APP_SECRET = os.environ.get("DROPBOX_APP_SECRET")
+pd.set_option('display.max_columns', None)
+
+
+def obtain_refresh_token(app_key, app_secret):
+    # Create a NoRedirectFlow object
+    auth_flow = DropboxOAuth2FlowNoRedirect(app_key, app_secret, token_access_type='offline')
+
+    # Generate the authorization URL
+    authorize_url = auth_flow.start()
+
+    # Print the authorization URL and instruct the user to visit it
+    print("1. Go to:", authorize_url)
+    print("2. Click 'Allow' (you might have to log in first)")
+    print("3. Copy the authorization code.")
+
+    # Prompt the user to enter the authorization code
+    auth_code = input("Enter the authorization code here: ").strip()
+
+    # Exchange the authorization code for an access token and refresh token
+    auth_result = auth_flow.finish(auth_code)
+    access_token = auth_result.access_token
+    refresh_token = auth_result.refresh_token
+    print(access_token)
+    print('\n\n')
+    print(refresh_token)
+    return access_token, refresh_token
+
+def dropbox_connect():
+    try:
+        dbx = dropbox.Dropbox(oauth2_access_token=DROPBOX_ACCESS_TOKEN, 
+                              oauth2_refresh_token=DROPBOX_REFRESH_TOKEN, 
+                              app_key=DROPBOX_APP_KEY,
+                              app_secret=DROPBOX_APP_SECRET)
+    except AuthError as err:
+        st.error(f'Erreur: Impossible de se connecter à la base de données - {err}')
+    return dbx
+
+def dropbox_list_files(path):
+    """Return a Pandas dataframe of files in a given Dropbox folder path in the Apps directory.
+    """
+
+    dbx = dropbox_connect()
+
+    try:
+        files = dbx.files_list_folder(path).entries
+        files_list = []
+        for file in files:
+            if isinstance(file, dropbox.files.FileMetadata):
+                metadata = {
+                    'name': file.name,
+                    'path_display': file.path_display,
+                    'client_modified': file.client_modified,
+                    'server_modified': file.server_modified
+                }
+                files_list.append(metadata)
+
+        df = pd.DataFrame.from_records(files_list)
+        return df.sort_values(by='server_modified', ascending=False)
+
+    except Exception as e:
+        print('Error getting list of files from Dropbox: ' + str(e))
+
+def dropbox_download_file(dropbox_file_path, local_file_path, load_data: bool = True):
+    """Download a file from Dropbox to the local machine."""
+
+    try:
+        dbx = dropbox_connect()
+        
+        metadata = dbx.files_get_metadata(dropbox_file_path)
+        if metadata:
+            metadata, result = dbx.files_download(path=dropbox_file_path)
+            if load_data:
+                with open(local_file_path, 'wb') as f:
+                    f.write(result.content)
+            return result.content
+
+        else:
+            print("Fichier non trouvé")
+            return None
+    except Exception as e:
+        if e.error.is_path() and e.error.get_path().is_not_found():
+            print("Fichier non trouvé")
+        return None
+
+def dropbox_upload_file(local_path, local_filename, dropbox_data_path, dropbox_file_name: str = None):
+    """Upload a file from the local machine to a path in the Dropbox app directory.
+
+    Args:
+        local_path (str): The path to the local file.
+        local_file (str): The name of the local file.
+        dropbox_file_path (str): The path to the file in the Dropbox app directory.
+
+    Example:
+        dropbox_upload_file('.', 'test.csv', '/stuff/test.csv')
+
+    Returns:
+        meta: The Dropbox file metadata.
+    """
+    try:
+        dbx = dropbox_connect()
+
+        local_file_path = os.path.join(local_path, local_filename)
+        dropbox_file_name = local_filename if not dropbox_file_name else dropbox_file_name
+        dropbox_file_path = os.path.join(dropbox_data_path, dropbox_file_name)
+   
+        with open(local_file_path,"rb") as f:
+            if not dropbox_check_path_exists(dropbox_data_path):
+                dropbox_create_folder(os.path.dirname(dropbox_data_path))
+            
+            meta = dbx.files_upload(f.read(), dropbox_file_path, mode=dropbox.files.WriteMode("overwrite"))
+            print("File uploaded successfully!")
+            return meta
+    except Exception as e:
+        print('Error uploading file to Dropbox: ' + str(e))
+
+def dropbox_upload_bytefile(dropbox_data_path, dropbox_file_name: str, bytes):
+    dropbox_file_path = os.path.join(dropbox_data_path, dropbox_file_name)
+
+    try:
+        dbx = dropbox_connect()
+        if not dropbox_check_path_exists(dropbox_data_path):
+            dropbox_create_folder(os.path.dirname(dropbox_data_path))
+        meta = dbx.files_upload(bytes.getvalue(), dropbox_file_path, mode=dropbox.files.WriteMode("overwrite"))
+        print("File uploaded successfully!")
+        return meta
+    except Exception as e:
+         print('Error uploading file to Dropbox: ' + str(e))
+
+def dropbox_create_folder(dropbox_folder_path):
+    """Create a folder in the Dropbox app directory.
+
+    Args:
+        dropbox_folder_path (str): The path to the folder in the Dropbox app directory.
+
+    Example:
+        dropbox_create_folder('/stuff')
+
+    Returns:
+        meta: The Dropbox folder metadata.
+    """
+
+    try:
+        dbx = dropbox_connect()
+
+        dbx.files_create_folder_v2(dropbox_folder_path)
+        print("Folder created successfully!")
+    except dropbox.exceptions.ApiError as e:
+        if e.error.is_path() and e.error.get_path().is_conflict():
+            print("Folder already exists!")
+        elif e.error.is_path() and e.error.get_path().is_not_found():
+            # Split the folder path into individual components
+            path_components = dropbox_folder_path.split("/")[1:]
+            current_path = ""
+            for component in path_components:
+                current_path += "/" + component
+                try:
+                    dbx.files_create_folder_v2(current_path)
+                    print(f"Created folder: {current_path}")
+                except dropbox.exceptions.ApiError as e:
+                    print(f"Error creating folder: {e}")
+        else:
+            print(f"Error creating folder: {e}")
+
+def dropbox_check_path_exists(dropbox_folder_path):
+    """Check if a folder exists in the Dropbox app directory.
+
+    Args:
+        dropbox_folder_path (str): The path to the folder in the Dropbox app directory.
+
+    Example:
+        dropbox_check_path_exists('/stuff')
+
+    Returns:
+        meta: The Dropbox folder metadata.
+    """
+
+    try:
+        dbx = dropbox_connect()
+
+        dbx.files_get_metadata(dropbox_folder_path)
+        return True
+    except dropbox.exceptions.ApiError as e:
+        if e.error.is_path() and e.error.get_path().is_not_found():
+            return False
+        else:
+            print(f"Error checking if folder exists: {e}", dropbox_folder_path)
+            return False
+
+@st.cache_data
+def dropbox_load_config_files(dropbox_datapath: str, local_datapath: str, excel_sources: List[dict]):
+    for key, value in excel_sources.items():
+        dropbox_download_file(os.path.join(dropbox_datapath, excel_sources[key]['path']), os.path.join(local_datapath, excel_sources[key]['path']))
+
+# obtain_refresh_token(DROPBOX_APP_KEY, DROPBOX_APP_SECRET)
+# df = dropbox_list_files('/SEC_IND_GTP2023_OUTPUT')
+# dropbox_create_folder('/SEC_IND_GTP2023_OUTPUT/TEST/FIT')
+# dropbox_create_folder('/SEC_IND_GTP2023_OZUTPUT/TEST/FIT')
+# print(df)

data/dataframes.py

@@ -0,0 +1,116 @@
+from typing import List
+import pandas as pd
+
+
+def merge_clients(data):
+    mnr_df = data['MNR_Client']
+    mnr_df['Prestataire'] = 'MNR'
+
+    stm_df = data['STM_Client']
+    stm_df['Prestataire'] = 'STM'
+
+    valm_df = data['VALM_Client']
+    valm_df['Prestataire'] = 'VALM'
+
+    data['Clients'] = pd.concat([mnr_df, stm_df, valm_df], ignore_index=True)
+    data['Clients'].rename(columns=dict(zip(data['Clients'].columns,['Code client', 'Type client', 'Nom client', 'Dist STE', 'Duration STE', 'Dist VAL', 'Duration VAL', 'Prestataire'])), inplace=True)
+    data['Clients'] = data['Clients'][data['Clients']['Type client'] == 'Client']
+
+    data['Clients']['Dist STE'] = data['Clients']['Dist STE'].fillna(0)
+    data['Clients']['Duration STE'] = data['Clients']['Duration STE'].fillna(0)
+    data['Clients']['Dist VAL'] = data['Clients']['Dist VAL'].fillna(0)
+    data['Clients']['Duration VAL'] = data['Clients']['Duration VAL'].fillna(0)
+
+    del data['MNR_Client']
+    del data['STM_Client']
+    del data['VALM_Client']
+
+
+def add_motifs_absences(df: pd.DataFrame, motifs: List[str]):
+    filtered_df = df[df['Nom client'].isin(['SECMI'])]
+    intervenants = df['Code intervenant (Identifiant du document de référence -> Document de vente)'].unique()
+    
+    for intervenant in intervenants:
+        rows = []
+        for motif in motifs['Libellé GTP2023'].tolist():
+            rows.append({
+                'Code intervenant (Identifiant du document de référence -> Document de vente)': intervenant,
+                'Code client': filtered_df.iloc[0]['Code client'] if filtered_df.shape[0] > 0 else 'SECMI',
+                'Nom client': filtered_df.iloc[0]['Nom client'] if filtered_df.shape[0] > 0 else 'SECMI',
+                'Code chantier': '000000',
+                'Libellé': motif
+
+            })
+        df = pd.concat([df, pd.DataFrame(rows)], ignore_index=True)
+    return df
+
+
+def merge_affaires(data):
+    mnr_df = data['MNR_Affaire']
+    mnr_df = add_motifs_absences(mnr_df, data['absences'])
+    mnr_df['Prestataire'] = 'MNR'
+
+    stm_df = data['STM_Affaire']
+    stm_df = add_motifs_absences(stm_df, data['absences'])
+    stm_df['Prestataire'] = 'STM'
+
+    valm_df = data['VALM_Affaire']
+    valm_df = add_motifs_absences(valm_df, data['absences'])
+    valm_df['Prestataire'] = 'VALM'
+
+    data['affaire'] = pd.concat([mnr_df, stm_df, valm_df], ignore_index=True)
+    data['affaire']['Code affaire'] = data['affaire']['Code chantier'] + ' - ' + data['affaire']['Libellé']
+    del data['affaire']['Code chantier']
+    del data['affaire']['Libellé']
+    data['affaire'].rename(columns=dict(zip(data['affaire'].columns,['Code intervenant', 'Code client', 'Nom client', 'prestataire', 'Code affaire'])), inplace=True)
+    del data['MNR_Affaire']
+    del data['STM_Affaire']
+    del data['VALM_Affaire']
+
+def merge_intervenants_affaires(data):
+    data['all'] = data['affaire'].merge(data['intervenants'], on='Code intervenant', how='left')
+    data['all'].rename(columns=dict(zip(['Code intervenant', 'Code affaire', 'Nom client', 'Code secteur géographique', 'Veh_Affecte', 'Durée Hebdo', 'Coût horaire'],['intervenant', 'affaire', 'client', 'secteur', 'vehicule affecte', 'contrat heures', 'cout horaire'])), inplace=True)
+    new_row  = pd.DataFrame([['-'] * (data['all'].shape[1])], columns=data['all'].columns)
+    data['all'] = pd.concat([new_row, data['all']], ignore_index=True)
+    data['all']['secteur'] = data['all']['secteur'].fillna('STE')
+    data['all']['contrat heures'] = data['all']['contrat heures'].fillna(0)
+    data['all']['cout horaire'] = data['all']['cout horaire'].fillna(0)
+    data['all'] = data['all'].dropna(subset=['intervenant', 'client', 'affaire'])
+
+def complete_vehicules(data):
+    data['vehicules']['vehicules'] = 'Collectif - ' + data['vehicules']['IMMAT'] + ' - ' + data['vehicules']['Description']
+    data['vehicules'].loc[len(data['vehicules'])] = [None, None, 'Perso']
+    data['vehicules'].loc[len(data['vehicules'])] = [None, None, 'Service affecté']
+
+def complete_supplements(data):
+    data['supplements'].rename(columns=dict(zip(data['supplements'].columns,['supplements'])), inplace=True)
+    data['supplements']['supplements'] = data['supplements']['supplements'].str.replace('_x000D_', ' ')
+    new_row  = pd.DataFrame([['-'] * (data['supplements'].shape[1])], columns=data['supplements'].columns)
+    data['supplements'] = pd.concat([new_row, data['supplements']], ignore_index=True)
+    data['supplements'] = data['supplements'][~data['supplements']['supplements'].isin([' H Peinture ', ' H  Qualif. Électrique ', ' H Soudure '])]
+
+def complete_affaires(data):
+    data['affaire'].rename(columns=dict(zip(['Code intervenant', 'Code affaire', 'Nom client'],['intervenant', 'affaire', 'client'])), inplace=True)
+    new_row  = pd.DataFrame([['-'] * (data['affaire'].shape[1])], columns=data['affaire'].columns)
+    data['affaire'] = pd.concat([new_row, data['affaire']], ignore_index=True)
+
+def complete_intervenants(data):
+    data['intervenants'].rename(columns=dict(zip(['Code intervenant',  'Code secteur géographique', 'Veh_Affecte', 'Durée Hebdo', 'Coût horaire'],['intervenant', 'secteur', 'vehicule affecte', 'contrat heures', 'cout horaire'])), inplace=True)
+    data['intervenants']['Employeur'] = data['intervenants']['Employeur'].apply(lambda x: x.split()[1] if pd.notna(x) else None)
+    data['intervenants']['Employeur'] = data['intervenants']['Employeur'].fillna('SECMI')
+    new_row  = pd.DataFrame([['-'] * (data['intervenants'].shape[1])], columns=data['intervenants'].columns)
+    data['intervenants'] = pd.concat([new_row, data['intervenants']], ignore_index=True)
+    #TODO to remove, for test only. Fill with 0
+    data['intervenants']['contrat heures'] = data['intervenants']['contrat heures'].fillna(35)
+
+def complete_arrets(data):
+    data['arrets'].rename(columns=dict(zip(data['arrets'].columns,['code_absence', 'H-35.0', 'H-37.0', 'H-37.5', 'H-39.0'])), inplace=True)
+    data['arrets']['code_absence'] = data['arrets']['code_absence'].str.replace('_x000D_', ' ')
+    data['arrets'].fillna(0, inplace=True)
+
+def cast_specifics_to_str(data):
+    data['all'] = data['all'].astype({'intervenant': str, 'affaire': str, 'client': str, 'prestataire': str})
+    data['vehicules'] = data['vehicules'].astype({'IMMAT': str, 'Description': str})
+    # print(data['affaire'])
+    data['affaire'] = data['affaire'].astype({'intervenant': str, 'affaire': str, 'client': str, 'prestataire': str})
+    data['intervenants'] = data['intervenants'].astype({'intervenant': str, 'secteur': str, 'vehicule affecte': str})

data/datastructures.py

@@ -0,0 +1,109 @@
+import pandas as pd
+import numpy as np
+from utils.times import date_to_week_day
+
+def generate_society_fit(form: dict):
+    society_form = {
+        "year": form["year"],
+        "month": form["month"],
+        "week": form["week"],
+        "date": form["date"],
+        "prestataire": form["prestataire"],
+        "client": form["client"],
+        "affaire": form["affaire"],
+        "intervenant": form["intervenant"],
+        "vehicule": form["vehicule"],
+        "location": form["location"],
+        "activities": form["activities"],
+        "worked_hours": form["worked_hours"],
+        "night_hours": form["night_hours"],
+        "drive_hours": form["drive_hours"],
+    }
+    return society_form
+    
+def generate_intervenant_monthly_payroll(form: pd.DataFrame):
+    historic_df = form
+    column_sums = {}
+    for column in historic_df.columns:
+        if historic_df[column].dtype in [int, float] \
+            and not np.isnan(historic_df[column]).all() \
+            and column not in ['year', 'month', 'week', 'date', 'public_holyday']:
+            column_sums[column] = historic_df[column].sum()
+    
+    payroll = {
+        "Nom": historic_df["nom"].values[0],
+        "Prénom": historic_df["prenom"].values[0],
+        "Semaine": f'{historic_df["year"].values[0]}-s{historic_df["week"].values[0]}',
+        "H Réal.": column_sums['worked_hours'],
+        "H Récup.": 0.,
+        "H Sup. Contrat": 0.,
+        "H Nuit": column_sums['night_hours'],
+        "H route": column_sums['drive_hours'],
+        "H Neg Non Just": 0.,
+        "H Neg Just": 0.,
+        "Ast Sem": column_sums['on_call_bonus'],
+        "Ast Sem/JF": 0.,
+        "Prime Interv.": column_sums['intervention_bonus'],
+        "Prime Chef Equipe": column_sums['team_leader_bonus'],
+        "Prime Transp. Caisse": column_sums['personal_tools_bonus'],
+        "Maladie": column_sums['maladie'],
+        "Arret Travail": column_sums['arret_travail'],
+        "Congés Payés": column_sums['conges_payes'],
+        "Congés Sans Solde": column_sums['conges_sans_solde'],
+        "RTT": column_sums['rtt'],
+        "Formation": column_sums['formation'],
+        "Evénement Familial": column_sums['evenement_familial'],
+        "Panier": column_sums['meal_nonus'],
+        "frais": 0.,
+        "H Samedi": column_sums['saturday_hours'],
+        # "H Dimanche / Férié": column_sums['sunday_hours'] + column_sums['holyday_hours'],
+        "H Dimanche": column_sums['sunday_hours'],
+        "H Férié": column_sums['holyday_hours'],
+
+    }
+    return payroll
+    
+
+def generate_intervenant_fit(form: dict):
+    data = form
+    fit_dict = {
+        "CLIENT": data["client"],
+        "Nom du responsable client": np.nan,
+        "AFFAIRE": data["affaire"],
+        "Lundi": data["worked_hours"] if date_to_week_day(data["date"]) == 'lundi' else 0,
+        "Mardi": data["worked_hours"] if date_to_week_day(data["date"]) == 'mardi' else 0,
+        "Mercredi": data["worked_hours"] if date_to_week_day(data["date"]) == 'mercredi' else 0,
+        "Jeudi": data["worked_hours"] if date_to_week_day(data["date"]) == 'jeudi' else 0,
+        "Vendredi": data["worked_hours"] if date_to_week_day(data["date"]) == 'vendredi' else 0,
+        "Samedi": data["worked_hours"] if date_to_week_day(data["date"]) == 'samedi' else 0,
+        "Dimanche": data["worked_hours"] if date_to_week_day(data["date"]) == 'dimanche' else 0,
+        "Travaux réalisés": data["activities"],
+        "H.\njour": data["worked_hours"] - data["night_hours"],
+        "H.\nnuit (1)": data["night_hours"],
+        "H.\nroute": data["drive_hours"],
+        "Panier (EUR)": data["meal_nonus"],
+        "Déplacement(EUR)": data["mileage_allowances_bonus"],
+        "Suppléments (EUR)": data["personal_tools_bonus"] + data["intervention_bonus"] + data["on_call_bonus"] + data["team_leader_bonus"],
+        "Véh. Perso (VP)\nou\nSociété (VS)": "VP" if data["vehicule"] == 'Perso' else "VS",
+        "Localisation": data["location"],
+    }
+    return fit_dict
+
+def generate_society_payroll(form: dict):
+    data = form
+    payroll = {
+        "Prestataire": data["employeur"],
+        "Fournisseur": data["prestataire"],
+        "year": data["year"],
+        "month": data["month"],
+        "client": data["client"],
+        "affaire": data["affaire"],
+        "intervenant": data["intervenant"],
+        "vehicule": data["vehicule"],
+        "Semaine": f'{data["year"]}-s{data["week"]}',
+        "H Réal.": data["worked_hours"],
+        "H Nuit": data["night_hours"],
+        "H route": data["drive_hours"],
+
+    }
+    return payroll

data/excels.py

@@ -0,0 +1,336 @@
+from io import BytesIO
+import os
+from typing import List, Tuple
+from openpyxl import Workbook
+from openpyxl.styles import Font
+from openpyxl.styles import Alignment
+from openpyxl.styles import numbers
+from openpyxl.styles.borders import Border, Side
+import streamlit as st
+import pandas as pd
+import numpy as np
+from data.cli_dropbox import dropbox_download_file, dropbox_upload_bytefile
+
+from .dataframes import complete_affaires, complete_arrets, complete_intervenants, complete_supplements, complete_vehicules, merge_clients, merge_affaires, merge_intervenants_affaires,cast_specifics_to_str
+
+def check_paths(paths: List[str]) -> bool:
+    files = []
+    for path in paths:
+        if not os.path.exists(path) or not os.path.isfile(path):
+            files.append(path)
+    return files
+    
+def load_excels(datapath: str, excel_sources: List[dict])  -> pd.DataFrame:
+    data = {}
+    for key, value in excel_sources.items():
+        data[key] = pd.read_excel(os.path.join(datapath, excel_sources[key]['path']),
+                           sheet_name=excel_sources[key]['sheet_name'],
+                            usecols=excel_sources[key]['columns'],
+                            nrows=excel_sources[key]['rows'],
+                            skiprows=excel_sources[key]['skiprows'],
+                        )
+    return data
+
+@st.cache_data
+def load_transform_data(datapath: str, excel_sources: List[dict]) -> pd.DataFrame:
+    not_files = check_paths([os.path.join(datapath, excel['path']) for excel in excel_sources.values()])
+    if len(not_files):
+        st.error(f'Erreur: une partie de la base de données n\'est pas accessible. {not_files}')
+        return
+
+    data = load_excels(datapath, excel_sources)
+    merge_clients(data)
+    merge_affaires(data)
+    merge_intervenants_affaires(data)
+
+    complete_vehicules(data)
+    complete_supplements(data)
+    complete_intervenants(data)
+    complete_affaires(data)
+    complete_arrets(data)
+    cast_specifics_to_str(data)
+    return data
+
+
+def filter_multiple_conditions_data(df, filters):
+    filtered_df = df[df[filters.keys()].isin(filters.values()).all(axis=1)]
+    return filtered_df
+
+def draw_border(sheet, start_cell: Tuple[int, int], end_cell: Tuple[int, int]):
+    # Define the border style
+    border_style = Border(left=Side(style='thin'),
+                      right=Side(style='thin'),
+                      top=Side(style='thin'),
+                      bottom=Side(style='thin'))
+
+    # Define the range of cells to apply borders to
+    start_cell = sheet.cell(row=start_cell[0], column=start_cell[1])
+    end_cell = sheet.cell(row=end_cell[0] , column=end_cell[1])
+    cell_range = '{}:{}'.format(start_cell.coordinate, end_cell.coordinate)
+
+    # Apply borders to the range of cells
+    for row in sheet[cell_range]:
+        for cell in row:
+            cell.border = border_style
+
+def get_fit_totals(dataframe):
+    column_sums = {}
+    for column in dataframe.columns:
+        if dataframe[column].dtype in [int, float] and not np.isnan(dataframe[column]).all():
+            column_sums[column] = dataframe[column].sum()
+    column_sums['rows'] = dataframe.shape[0]
+    column_sums['worked_hours'] = column_sums['H.\njour'] + column_sums['H.\nnuit (1)']
+    return column_sums
+
+def load_fit(datapath: str, intervenant: str, year: str, month: str, week: str):
+    filename = f'{intervenant}_{year}_{month}_{week}_FIT.xlsx'
+    if dropbox_download_file(f'/SEC_IND_GTP2023_OUTPUT/FIT/{intervenant}/{year}/{month}/{week}/{filename}', os.path.join(datapath, filename)):
+        #TODO get file from dropbox
+        if os.path.exists(os.path.join(datapath, filename)) and os.path.isfile(os.path.join(datapath, filename)):
+            data = pd.read_excel(os.path.join(datapath, filename), sheet_name='Sheet', skiprows=6, nrows=10)
+            data.dropna(axis=0, how='all', inplace=True)
+            totals = get_fit_totals(data)
+
+            if 'fit' not in st.session_state.keys():
+                st.session_state['fit'] = {}
+            
+            if intervenant not in st.session_state['fit'].keys():
+                st.session_state['fit'][intervenant] = {}
+            if year not in st.session_state['fit'][intervenant].keys():
+                st.session_state['fit'][intervenant][year] = {}
+            if month not in st.session_state['fit'][intervenant][year].keys():
+                st.session_state['fit'][intervenant][year][month] = {}
+            if week not in st.session_state['fit'][intervenant][year][month].keys():
+                st.session_state['fit'][intervenant][year][month][week] = {}
+            st.session_state['fit'][intervenant][year][month][week] = {
+                'data': data,
+                'totals': totals
+            }
+
+            return data
+    print('error loading fit')
+    return None
+
+async def update_society_fit(dropbox_datapath: str, form: dict):
+    society = form['prestataire']
+    year = form['year']
+    month = form['month']
+    week = form['week']
+    dropbox_path = f'{dropbox_datapath}/SOCIETE/{society}/{year}/{month}/{week}'
+
+    filename = f'{society}_{year}_{month}_{week}_FIT.csv'
+    fit_df = pd.DataFrame([form])
+
+    fit = dropbox_download_file(os.path.join(dropbox_path, filename), '', False)
+    if fit:
+        fit = pd.read_csv(BytesIO(fit), index_col=0)
+        fit_df = pd.concat([fit, fit_df], ignore_index=True)
+
+    csv_data = BytesIO()
+    fit_df.to_csv(csv_data, index = False)
+    dropbox_upload_bytefile(dropbox_data_path=dropbox_path, dropbox_file_name=filename, bytes=csv_data)
+    return fit_df
+
+
+async def update_society_payroll(dropbox_datapath: str, form: dict):
+    prestataire = form['Prestataire']
+    fournisseur = form['Fournisseur']
+    year = form['year']
+    month = form['month']
+    dropbox_path = f'{dropbox_datapath}/PRESTATIONS/{prestataire}/{year}/{month}'
+
+    filename = f'{prestataire}_{fournisseur}_{year}_{month}_PRESTATIONS_CROISEES.xlsx'
+    payroll_df = pd.DataFrame([form])
+
+    payroll = dropbox_download_file(os.path.join(dropbox_path, filename), '', False)
+    if payroll:
+        payroll = pd.read_excel(BytesIO(payroll))
+        payroll_df = pd.concat([payroll, payroll_df], ignore_index=True)
+
+    excel_data = BytesIO()
+    payroll_df.to_excel(excel_data, index = False)
+    dropbox_upload_bytefile(dropbox_data_path=dropbox_path, dropbox_file_name=filename, bytes=excel_data)
+    return payroll_df
+
+async def update_historical_week(dropbox_datapath: str, form: dict):
+    intervenant = form['intervenant']
+    year = form['year']
+    month = form['month']
+    week = form['week']
+    dropbox_path = f'{dropbox_datapath}/FIT/{intervenant}/{year}/{month}/{week}'
+
+    historic_df = pd.DataFrame([form])
+
+    historic = dropbox_download_file(dropbox_path + '/historique.xlsx', '', False)
+    if historic:
+        historic = pd.read_excel(historic)
+        historic_df = pd.concat([historic, historic_df], ignore_index=True)
+
+    excel_data = BytesIO()
+    historic_df.to_excel(excel_data, index = False)
+    dropbox_upload_bytefile(dropbox_data_path=dropbox_path, dropbox_file_name='historique.xlsx', bytes=excel_data)
+    return historic_df
+
+async def update_monthly_payroll(dropbox_datapath: str, payroll_dict: dict, year: str, month: str, week: str):
+
+    dropbox_path = f'{dropbox_datapath}/PAYES'
+    # dropbox_path = dropbox_datapath
+    nom = payroll_dict['Nom']
+    prenom = payroll_dict['Prénom']
+    payroll_df = pd.DataFrame([payroll_dict])
+
+    payroll = dropbox_download_file(dropbox_path + f'/tableau_prepaye_{year}_{month}.xlsx', '', False)
+    if payroll:
+        payroll = pd.read_excel(payroll)
+        intervenant_rows = payroll[(payroll['Nom'] == nom) & (payroll['Prénom'] == prenom)]
+        # print(len(intervenant_rows))
+        if len(intervenant_rows):
+            current_week_row = payroll[(payroll['Nom'] == nom) & (payroll_df['Prénom'] == prenom) & (payroll['Semaine'] == f'{year}-s{week}')]
+            # print(len(current_week_row))
+            if len(current_week_row):
+                payroll.iloc[current_week_row.index] = payroll_df.loc[0]
+                payroll_df = payroll
+            else:
+                payroll_df = pd.concat([payroll, payroll_df], ignore_index=True)
+        else:
+            payroll_df = pd.concat([payroll, payroll_df], ignore_index=True)
+    rows_for_total = payroll_df[(payroll_df['Nom'] == nom) & (payroll_df['Prénom'] == prenom) & (payroll_df['Semaine'].str.contains(f'{year}-s'))]
+    total = pd.DataFrame([rows_for_total.drop(columns=['Nom', 'Prénom', 'Semaine']).sum()])
+    total['Nom'] = nom
+    total['Prénom'] = prenom
+    total['Semaine'] = 'TOTAL'
+    all_but_total = payroll_df[~((payroll_df['Nom'] == nom) & (payroll_df['Prénom'] == prenom) & (payroll_df['Semaine'].str.contains('TOTAL')))]
+    # print(all_but_total)
+    payroll_df = pd.concat([total, all_but_total], ignore_index=True, axis = 0)
+    # print(payroll_df)
+    payroll_df = payroll_df.sort_values(by=['Nom', 'Prénom', 'Semaine'])
+    column_order = payroll_df.columns[-3:].tolist() + payroll_df.columns[:-3].tolist()
+    payroll_df = payroll_df[column_order]   
+    excel_data = BytesIO()
+    payroll_df.to_excel(excel_data, index = False)
+    dropbox_upload_bytefile(dropbox_data_path=dropbox_path, dropbox_file_name=f'tableau_prepaye_{year}_{month}.xlsx', bytes=excel_data)
+    return payroll_df
+
+def write_excel_fit(datapath: str, filename: str, data, starting_row = 7):
+    workbook = Workbook()
+    sheet = workbook.active
+
+    
+    sheet.column_dimensions['A'].width = 60
+    sheet.column_dimensions['B'].width = 40
+    sheet.column_dimensions['C'].width = 80
+    sheet.column_dimensions['D'].width = 40
+    sheet.column_dimensions['E'].width = 20
+    sheet.column_dimensions['K'].width = 60
+    sheet.column_dimensions['L'].width = 40
+    sheet.column_dimensions['M'].width = 40
+    sheet.column_dimensions['O'].width = 20
+    sheet.column_dimensions['P'].width = 40
+    sheet.column_dimensions['Q'].width = 40
+    sheet.column_dimensions['R'].width = 40
+    sheet.column_dimensions['S'].width = 20
+    sheet.row_dimensions[29].height = 30
+    sheet.row_dimensions[31].height = 40
+
+    sheet['A1'] = 'SECMI'
+
+    sheet['D1'] = 'FICHE D\'INTERVENTION ET DE TEMPS (FIT)'
+
+    sheet['A3'] = f'Intervenant: {data["intervenant"]}'
+    draw_border(sheet, (3, 1), (3, 1))
+
+    sheet.merge_cells('M1:N1')
+    sheet['M1'] = f'Année: {data["year"]}'
+    draw_border(sheet, (1, 13), (1, 13))
+    
+    sheet.merge_cells('M2:N2')
+    sheet['M2'] = f'Semaine: {data["week"]}'
+    draw_border(sheet, (2, 13), (2, 13))
+
+
+    sheet['A18'] = '(1)  travail effectué entre 21h00 et 06h00'
+
+    sheet.merge_cells('A19:S22')
+    sheet['A19'] = 'Commentaires SECMI:'
+    draw_border(sheet, (19, 1), (22, 19))
+
+    sheet.merge_cells('A23:S26')
+    sheet['A23'] = 'Commentaires Client:'
+    draw_border(sheet, (23, 1), (26, 19))
+
+    sheet.merge_cells('A30:D30')
+    sheet['A30'] = 'Signature client:'
+    draw_border(sheet, (30, 1), (30, 4))
+    sheet.merge_cells('A31:D32')
+    draw_border(sheet, (31, 1), (32, 4))
+
+    
+    sheet['E30'] = 'Note\n(de 0 à 10)'
+    draw_border(sheet, (30, 5), (30, 5))
+    sheet.merge_cells('E31:E32')
+    draw_border(sheet, (31, 5), (32, 5))
+
+    sheet['L30'] = 'Signature chargé d\'affaire:'
+    draw_border(sheet, (30, 12), (30, 12))
+    sheet.merge_cells('L31:L32')
+    draw_border(sheet, (31, 12), (32, 12))
+
+    sheet['M30'] = 'Signature intervenant:'
+    draw_border(sheet, (30, 13), (30, 13))
+    sheet.merge_cells('M31:M32')
+    draw_border(sheet, (31, 13), (32, 13))
+    
+
+    sheet.merge_cells('A33:T33')
+    sheet.merge_cells('A34:T34')
+    draw_border(sheet, (33, 1), (34, 19))
+    sheet['A33'] = 'Service Administratif'
+    sheet['A34'] = 'Tel: +33 6 02 14 55 16  - Email : [email protected]'
+    # Define the starting row for writing the dictionary
+    
+    draw_border(sheet, (starting_row, 1), (starting_row + 10, 19))
+
+    draw_border(sheet, (starting_row - 2, 4), (starting_row -2, 19))
+
+
+    sheet.cell(row=starting_row - 2, column=4, value='TOTAUX (en heure)')
+    # Write the dictionary to the sheet starting from the specified row
+    header = list(data['data'].keys())
+    for col_i, key in enumerate(header):
+        sheet.cell(row=starting_row, column=col_i + 1, value=key)
+        if key in data['totals'].keys():
+            sheet.cell(row=starting_row - 2, column=col_i + 1, value=data['totals'][key])
+
+    for cell in sheet[starting_row - 2]:
+        cell.font = Font(bold=True)
+    for cell in sheet[starting_row]:
+        cell.font = Font(bold=True)
+
+    starting_row += 1
+    for col_i, key in enumerate(data['data'].keys()):
+            values = data['data'][key]
+            for j, value in enumerate(values):
+
+                sheet.cell(row=starting_row + j, column=col_i + 1, value=value)
+
+    alignment = Alignment(horizontal='center', vertical='center')
+    # Set the decimal format
+    decimal_format = numbers.FORMAT_NUMBER_00
+
+    for row in sheet.iter_rows():
+        for cell in row:
+            cell.alignment = alignment
+            cell.number_format = decimal_format
+   
+    sheet['A1'].font = Font(bold=True, underline='single', size=11)
+    sheet['D1'].font = Font(bold=True, underline='single', size=11)
+    sheet['A19'].font = Font(bold=True, underline='single')
+    sheet['A19'].alignment = Alignment(horizontal='left', vertical='top')
+    sheet['A23'].font = Font(bold=True, underline='single')
+    sheet['A23'].alignment = Alignment(horizontal='left', vertical='top')
+    sheet['A33'].font = Font(bold=True)
+    sheet['A33'].alignment = Alignment(horizontal='center')
+    sheet['A34'].font = Font(bold=True)
+    sheet['A34'].alignment = Alignment(horizontal='center')
+
+    workbook.save(os.path.join(datapath, filename))

data/test.py

@@ -0,0 +1,36 @@
+import yaml
+from yaml.loader import SafeLoader
+
+# from excels import load_excels
+# from dataframes import merge_clients, merge_affaires, merge_intervenants_affaires
+# from const import root_path 
+
+# with open(f'{root_path}/config.yaml') as file:
+#     config = yaml.load(file, Loader=SafeLoader)
+
+
+# print(config['data'])
+# data = load_excels(root_path, config['data'])
+# merge_clients(data)
+# merge_affaires(data)
+# merge_intervenants_affaires(data)
+# print(data)
+# print(data['Clients'])
+# print(data['Affaire'])
+
+def find_substring_in_list(substring, string_list):
+    found_strings = [string for string in string_list if string.find(substring) != -1]
+    return found_strings
+
+string_list = ['absence test', 'absence test 2', 'absence test 3', '0000- absence']
+substring = 'zzz'
+print(find_substring_in_list(substring, string_list))
+# Example usage
+# device_id = get_device_id()
+# current_ip = get_current_ip()
+# print("Current IP:", current_ip)
+# print("Device ID:", device_id)
+
+# film
+# bail jojo
+# garage

dockerfile

@@ -0,0 +1,33 @@
+# app/Dockerfile
+
+FROM python:3.10.6-slim
+
+WORKDIR /app
+
+ENV PYTHONPATH=/app:$PYTHONPATH
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    locales \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN sed -i -e 's/# fr_FR.UTF-8 UTF-8/fr_FR.UTF-8 UTF-8/' /etc/locale.gen && \
+    locale-gen
+
+# Set the locale environment variables
+ENV LANG=fr_FR.UTF-8
+ENV LC_ALL=fr_FR.UTF-8
+
+COPY . .
+
+RUN pip3 install --upgrade pip
+RUN pip3 install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "main.py", "--server.port=8501", "--server.address=0.0.0.0"]

main.py

@@ -0,0 +1,173 @@
+import datetime as dt
+import os
+import numpy as np
+import pandas as pd
+import streamlit as st
+import yaml
+from yaml.loader import SafeLoader
+from data.cli_dropbox import dropbox_load_config_files
+
+from data.excels import load_fit, load_transform_data, filter_multiple_conditions_data
+from utils.times import calculate_night_time, calculate_work_time, date_to_week_number
+from utils.btn_behaviors import reset, validate_duplicate, validate_end
+from utils.indemnites import calculate_astreinte, calculate_indemnites_km, calculate_overtimes
+
+from const import root_path 
+
+st.set_page_config(layout="wide") 
+
+with open(os.path.join(root_path, 'config.yaml')) as file:
+    config = yaml.load(file, Loader=SafeLoader)
+pd.set_option('display.max_columns', None)
+
+#TODO download dropbox config files
+if not 'dropbox_update' in st.session_state.keys():
+    dropbox_load_config_files('/SEC_IND_GTP2023_INPUT', os.path.join(root_path, 'data/input'), config['data'])
+    st.session_state.dropbox_update = True
+df = load_transform_data(os.path.join(root_path, 'data/input'), config['data'])
+
+# print("session_state", st.session_state)
+def affaire_change(indexes, df_key):
+    filters = {}
+    new_values = []
+    
+    for key, value in st.session_state.items():
+        if key in df[df_key].columns and key not in ['intervenant', 'prestataire']:
+            if st.session_state[key] != '-':
+                filters[key] = value
+                new_values.insert(len(new_values), value)
+            indexes[key] = 0
+    
+    st.session_state.df[df_key] = filter_multiple_conditions_data(df[df_key], filters)
+
+    new_row  = pd.DataFrame([['-'] * (df[df_key].shape[1])], columns=df[df_key].columns)
+    for key, value in filters.items():
+        indexes[key] = 1 if value != '-'else 0
+            
+    st.session_state.df[df_key] = pd.concat([new_row, st.session_state.df[df_key]], ignore_index=True)
+
+def intervenant_change():            
+    if "intervenant" in st.session_state and st.session_state.intervenant != '-':
+        st.session_state.contract_hours = st.session_state.df['intervenants'][st.session_state.df['intervenants']['intervenant'] == st.session_state.intervenant]['contrat heures'].values[0]
+        st.session_state.supp_contract_hours = st.session_state.df['intervenants'][st.session_state.df['intervenants']['intervenant'] == st.session_state.intervenant]['contrat heures'].values[0]
+        load_fit(datapath=os.path.join(root_path, 'data/output'), intervenant=st.session_state.intervenant, year=st.session_state.date_input.year, month= st.session_state.date_input.month ,week=date_to_week_number(st.session_state.date_input))
+
+if 'df' not in st.session_state:
+    st.session_state.df = df
+    st.session_state.indexes_all = {k: 0 for k in df['all'].columns}
+    st.session_state.indexes_vehicules = {k: 0 for k in df['vehicules'].columns}
+    st.session_state.indexes_affaire = {k: 0 for k in df['affaire'].columns}
+    st.session_state.indexes_intervenants = {k: 0 for k in df['intervenants'].columns}
+
+
+st.title('SECMI - Gestion des temps passés')
+codes = st.columns(3)
+
+intervenant = codes[0].selectbox('Intervenant', np.sort(st.session_state.df['intervenants'].intervenant.unique()), key='intervenant', on_change=intervenant_change)
+client = codes[1].selectbox('Client', np.sort(st.session_state.df['affaire'].client.unique()), key='client', on_change=affaire_change, kwargs={'indexes': st.session_state.indexes_affaire, 'df_key': 'affaire'}, index=st.session_state.indexes_affaire['client'])
+location = codes[2].selectbox('Localisation', np.sort(['En Atelier', 'En Clientèle']), key='location')
+
+# prestataire = codes[3].selectbox('Prestataire', np.sort(st.session_state.df['all'].prestataire.unique()), key='prestataire', on_change=value_change, kwargs={'indexes': st.session_state.indexes_all, 'df_key': 'all'}, index=st.session_state.indexes_all['prestataire'])
+st.session_state.prestataire = st.session_state.df['affaire']['prestataire'][1]
+affaire = st.selectbox('Affaire', np.sort(st.session_state.df['affaire'].affaire.unique()), key='affaire', on_change=affaire_change, kwargs={'indexes': st.session_state.indexes_affaire, 'df_key': 'affaire'}, index=st.session_state.indexes_affaire['affaire'])
+vehicules = st.selectbox('vehicules', np.sort(st.session_state.df['vehicules'].vehicules.unique()), key='vehicules')#, on_change=value_change,kwargs={'indexes': st.session_state.indexes_vehicules, 'df_key': 'vehicules'}, index=st.session_state.indexes_vehicules['Description'])
+
+absences = st.session_state.df['absences']['Libellé GTP2023'].tolist()
+absences.remove('Absence Formation')
+st.session_state.disable_times = True if len([string for string in absences if affaire.find(string) != -1]) else False
+
+st.divider()
+activites = st.text_area('Description des activités effectuées', key="activities_text_area")
+
+st.divider()
+temps = st.columns(5)
+
+if 'date_input' not in st.session_state:
+    st.session_state.date_input = dt.datetime.now()
+
+# print(df['arrets'])
+date = temps[0].date_input(
+    label="Date de la mission", 
+    value=st.session_state.date_input, 
+    min_value=dt.datetime.now() - dt.timedelta(days=15),
+    max_value=dt.datetime.now(),
+    on_change=load_fit,
+    kwargs={'datapath': os.path.join(root_path, 'data/output'), 'intervenant': st.session_state.intervenant, 'year': st.session_state.date_input.year, 'month': st.session_state.date_input.month, 'week': date_to_week_number(st.session_state.date_input)},
+    key='date_input')
+
+# if 'fit' in st.session_state.keys():
+#     print(st.session_state.fit)
+# print(date_to_week_number(date), date_to_week_day(date))
+public_holyday = temps[0].checkbox('Jour Férié', key="public_holyday")
+start_time = temps[1].time_input('heure début', dt.time(8, 00), key='start_time_input', disabled=st.session_state.disable_times)
+end_time = temps[2].time_input('heure fin', dt.time(16, 00), key='end_time_input', disabled=st.session_state.disable_times)
+
+
+pause_time = temps[3].time_input('temps de pause', dt.time(1, 00), step=300, key='pause_time_input')
+
+st.session_state.total_hours = calculate_work_time(start_time, end_time, pause_time, date)
+st.session_state.night_hours = calculate_night_time(start_time, end_time, pause_time, date)
+
+if st.session_state.total_hours > 8:
+    st.warning('Les heures de travail enregistrées sont supérieures à 8 heures !')
+
+
+# print(st.session_state.df['supplements'].columns)
+supplements = temps[4]
+supplement1 = supplements.selectbox('Supplement 1', st.session_state.df['supplements'].supplements, key = 'supplement1')
+supplement2 = supplements.selectbox('Supplement 2', st.session_state.df['supplements'].supplements, key = 'supplement2')
+supplement3 = supplements.selectbox('Supplement 3', st.session_state.df['supplements'].supplements, key = 'supplement3')
+
+st.session_state.meal_bonus = 9.15 if st.session_state.total_hours >= 6.15 else 0
+st.session_state.personal_tools_bonus = 3.2 if ' Transp.  Caisse ' in [supplement1, supplement2, supplement3 ] else 0
+st.session_state.intervention_bonus = 1 * st.session_state.total_hours if 'Prime Interv°' in [supplement1, supplement2, supplement3 ] else 0
+st.session_state.on_call_bonus = calculate_astreinte() if st.session_state.intervenant != '-' and 'Astreinte Sem' in [supplement1, supplement2, supplement3 ] else 0
+st.session_state.team_leader_bonus =  10 if 'Prime Chef Equ' in [supplement1, supplement2, supplement3 ] else 0
+
+# st.session_state.painting_bonus = 1 * st.session_state.total_hours if ' H Peinture ' in [supplement1, supplement2, supplement3 ] else 0
+# st.session_state.electrical_bonus = 1 * st.session_state.total_hours if ' H  Qualif. Électrique ' in [supplement1, supplement2, supplement3 ] else 0
+# st.session_state.welding_bonus = 1 * st.session_state.total_hours if ' H Soudure ' in [supplement1, supplement2, supplement3 ] else 0
+
+st.session_state.overtime25, st.session_state.overtime50, st.session_state.overtime100 = calculate_overtimes()
+
+st.session_state.mileage_allowances_bonus , st.session_state.drive_hours = calculate_indemnites_km()
+
+year = st.session_state.date_input.year
+month = st.session_state.date_input.month
+week = date_to_week_number(st.session_state.date_input)
+st.divider()
+infos = st.columns(3, gap="large")
+infos[0].header(f'Temps total: ')
+infos[0].write(f'Temps de travail: {st.session_state.total_hours } heure(s)')
+infos[0].write(f'Temps de pause: {pause_time.hour + (pause_time.minute / 60)} heure(s)')
+infos[0].write(f'Heure de nuit: {st.session_state.night_hours} heure(s)')
+infos[0].write(f'Jour Férié: {"oui" if public_holyday else "non"}')
+
+if 'fit' in st.session_state.keys() and  st.session_state.intervenant in st.session_state['fit'].keys() and year in st.session_state.fit[st.session_state.intervenant].keys() and month in st.session_state.fit[st.session_state.intervenant][year].keys() and week in st.session_state.fit[st.session_state.intervenant][year][month].keys():
+    infos[0].write(f'Heures indiquées dans le contrat de travail: {st.session_state.contract_hours} heures')
+    if st.session_state.contract_hours > 35:
+        infos[0].write(f'Dont Heures supplémentaires inclues dans le contrat: {st.session_state.supp_contract_hours} heures')
+
+    infos[0].write(f'Heures totales de travail pour la semaine {week} : {st.session_state.fit[st.session_state["intervenant"]][year][month][week]["totals"]["worked_hours"]} heures')
+
+    infos[0].write(f'Heure supp 25%: {st.session_state.overtime25} heure(s)')
+    infos[0].write(f'Heure supp 50%: {st.session_state.overtime50} heure(s)')
+    infos[0].write(f'Heure supp 100%: {st.session_state.overtime100} heure(s)')
+
+infos[1].header('Informations:')
+if st.session_state.mileage_allowances_bonus > 0:
+    infos[0].write(f'Heure route: {st.session_state.drive_hours} heure(s)')
+    infos[1].write(f'Indemnités kilométriques: {st.session_state.mileage_allowances_bonus}€')
+
+infos[1].write(f'Panier: {st.session_state.meal_bonus}€')
+infos[1].write(f'Transport de caisse: {st.session_state.personal_tools_bonus}€')
+infos[1].write(f'Prime d\'intervention: {st.session_state.intervention_bonus}€')
+infos[1].write(f'Prime d\'astreinte: {st.session_state.on_call_bonus}€')
+infos[1].write(f'Prime chef d\'équipe: {st.session_state.team_leader_bonus}€')
+# infos[1].write(f'Autre (Peinture, Soudure, Electricité): {st.session_state.electrical_bonus + st.session_state.painting_bonus + st.session_state.welding_bonus}€')
+
+reset_btn = infos[2].button('Effacer', on_click=reset, kwargs={"df": df})
+validate_duplicate_btn = infos[2].button('Valider et Dupliquer', on_click=validate_duplicate)
+validate_end_btn = infos[2].button('Valider et Terminer', on_click=validate_end)
+
+

requirements.txt

@@ -0,0 +1,8 @@
+Babel==2.12.1
+dropbox==11.36.2
+streamlit==1.25.0
+pandas==1.5.3
+numpy==1.23.5
+openpyxl==3.1.2
+python-dotenv==1.0.0
+pyyaml

utils/btn_behaviors.py

@@ -0,0 +1,219 @@
+import os
+import numpy as np
+import pandas as pd
+import streamlit as st
+import datetime as dt
+from data.cli_dropbox import dropbox_upload_file
+from data.datastructures import generate_intervenant_fit, generate_intervenant_monthly_payroll, generate_society_fit, generate_society_payroll
+
+from data.excels import get_fit_totals, update_historical_week, update_monthly_payroll, update_society_fit, update_society_payroll, write_excel_fit
+from utils.indemnites import calculate_arrets
+from utils.times import date_to_week_day, date_to_week_number
+from utils.device import get_current_ip, get_device_id
+from const import root_path
+import asyncio
+
+
+def merge_dicts(list_of_dicts):
+    merged_dict = {}
+
+    for dictionary in list_of_dicts:
+        for key, value in dictionary.items():
+            if key not in merged_dict:
+                merged_dict[key] = []
+            merged_dict[key].append(value)
+
+    return merged_dict
+
+@st.cache_resource
+async def read_transform_write_excel(datapath: str = f'{root_path}/data/output', form: dict = None):
+    fit_data = {
+        "year": form["year"],
+        "month": form["month"],
+        "week": form["week"],
+        "intervenant": form["intervenant"],
+    }
+
+    fit_dict = generate_intervenant_fit(form)
+    fit_df = pd.DataFrame(fit_dict, index=[0])
+
+    
+    if 'fit' in st.session_state.keys() \
+        and form["intervenant"] in st.session_state['fit'].keys() \
+        and form["year"] in st.session_state['fit'][form["intervenant"]].keys() \
+        and form["month"] in st.session_state['fit'][form["intervenant"]][form["year"]].keys() \
+        and form["week"] in st.session_state['fit'][form["intervenant"]][form["year"]][form["month"]].keys():
+        df = st.session_state['fit'][form["intervenant"]][form["year"]][form["month"]][form["week"]]['data']
+        # Concatenate DataFrame and dictionary DataFrame
+        fit_df = pd.concat([df, fit_df], ignore_index=True)
+
+    totals = get_fit_totals(fit_df)
+    fit_data['data'] = fit_df
+    fit_data['totals'] = totals
+    path = f'{form["intervenant"]}_{form["year"]}_{form["month"]}_{form["week"]}_FIT.xlsx'
+
+    write_excel_fit(datapath, path, fit_data)
+    dropbox_upload_file(datapath, path, f'/SEC_IND_GTP2023_OUTPUT/FIT/{form["intervenant"]}/{form["year"]}/{form["month"]}/{form["week"]}', path)
+    
+    
+    if 'fit' not in st.session_state.keys():
+        st.session_state['fit'] = {}
+    
+    if form["intervenant"] not in st.session_state['fit'].keys():
+        st.session_state['fit'][form["intervenant"]] = {}
+    if form["year"] not in st.session_state['fit'][form["intervenant"]].keys():
+        st.session_state['fit'][form["intervenant"]][form["year"]] = {}
+    if form["month"] not in st.session_state['fit'][form["intervenant"]][form["year"]].keys():
+        st.session_state['fit'][form["intervenant"]][form["year"]][form["month"]] = {}
+    if form["week"] not in st.session_state['fit'][form["intervenant"]][form["year"]][form["month"]].keys():
+        st.session_state['fit'][form["intervenant"]][form["year"]][form["month"]][form["week"]] = {}
+    st.session_state['fit'][form["intervenant"]][form["year"]][form["month"]][form["week"]] = {
+        'data': fit_data['data'],
+        'totals': totals
+    }
+    st.toast('Fiche de temps envoyée', icon="📨")
+    return st.session_state['fit'][form["intervenant"]][form["year"]][form["month"]][form["week"]]
+
+def validate():
+    data_dict = {
+        "intervenant": st.session_state.intervenant,
+        "nom": st.session_state.df['intervenants'][st.session_state.df['intervenants']['intervenant'] == st.session_state.intervenant]['Nom'].values[0],
+        "prenom": st.session_state.df['intervenants'][st.session_state.df['intervenants']['intervenant'] == st.session_state.intervenant]['Prénom'].values[0],
+        "employeur": st.session_state.df['intervenants'][st.session_state.df['intervenants']['intervenant'] == st.session_state.intervenant]['Employeur'].values[0],
+        "client": st.session_state.client,
+        "affaire": st.session_state.affaire,
+        "prestataire": st.session_state.prestataire, 
+        "vehicule": st.session_state.vehicules, 
+        "location": st.session_state.location,
+        "activities": st.session_state.activities_text_area, 
+
+        "date": st.session_state.date_input,
+        "year": st.session_state.date_input.year,
+        "month": st.session_state.date_input.month,
+        "week": date_to_week_number(st.session_state.date_input), 
+        "public_holyday": st.session_state.public_holyday, 
+        "start_time": st.session_state.start_time_input, 
+        "end_time": st.session_state.end_time_input, 
+
+        "pause_time": st.session_state.pause_time_input, 
+        "supplement_1": st.session_state.supplement1,
+        "supplement_2": st.session_state.supplement2,
+        "supplement_3": st.session_state.supplement3,
+
+        # "contract_hours": st.session_state.df['all'].contract_hours[st.session_state.indexes_all['contract_hours']],
+        # "maladie": st.session_state.total_hours if st.session_state.affaire.find('Absence Maladie Individuelle') != -1 or \
+        #                                             st.session_state.affaire.find('Absence Maladie Professionnelle') != -1 \
+        #                                         else 0,
+        "maladie": calculate_arrets() if st.session_state.affaire.find('Absence Maladie Individuelle') != -1 or \
+                                        st.session_state.affaire.find('Absence Maladie Professionnelle') != -1 \
+                                        else 0,
+        "arret_travail": calculate_arrets() if st.session_state.affaire.find('Absence Accident du Travail') != -1 else 0,
+        "conges_payes": calculate_arrets() if st.session_state.affaire.find('Absence Congés payés') != -1 else 0,
+        "conges_sans_solde": calculate_arrets() if st.session_state.affaire.find('Absence Congés sans solde') != -1 else 0,
+        "rtt": calculate_arrets() if st.session_state.affaire.find('Absence RTT') != -1 else 0,
+        "formation": calculate_arrets() if st.session_state.affaire.find('Absence Formation') != -1 else 0,
+        "evenement_familial": calculate_arrets() if st.session_state.affaire.find('Absence Evénement Familial') != -1 else 0,
+        
+        
+        "worked_hours": st.session_state.total_hours if st.session_state.total_hours else 0,
+        "night_hours": st.session_state.night_hours if st.session_state.night_hours else 0,
+        "contract_hours": st.session_state.contract_hours if st.session_state.contract_hours else 0,
+        "supp_contract_hours": st.session_state.supp_contract_hours if st.session_state.supp_contract_hours else 0,
+        "day_hours": st.session_state.total_hours - st.session_state.night_hours if st.session_state.total_hours and st.session_state.night_hours else 0,
+        "drive_hours": st.session_state.drive_hours if st.session_state.drive_hours else 0,
+        "saturday_hours": st.session_state.total_hours if date_to_week_day(st.session_state.date_input) == 'samedi' else 0,
+        "sunday_hours": st.session_state.total_hours if date_to_week_day(st.session_state.date_input) == 'dimanche' else 0,
+        "holyday_hours": st.session_state.total_hours if st.session_state.public_holyday else 0,
+        "overtime_25": st.session_state.overtime25 if st.session_state.overtime25 else 0,
+        "overtime_50": st.session_state.overtime50 if st.session_state.overtime50 else 0,
+        "overtime_100": st.session_state.overtime100 if st.session_state.overtime100 else 0,
+
+        "meal_nonus": st.session_state.meal_bonus if st.session_state.meal_bonus else 0,
+        "mileage_allowances_bonus": st.session_state.mileage_allowances_bonus if st.session_state.mileage_allowances_bonus else 0,
+        "personal_tools_bonus": st.session_state.personal_tools_bonus  if st.session_state.personal_tools_bonus else 0,
+        "intervention_bonus": st.session_state.intervention_bonus if st.session_state.intervention_bonus else 0,
+        "on_call_bonus": st.session_state.on_call_bonus if st.session_state.on_call_bonus else 0,
+        "team_leader_bonus": st.session_state.team_leader_bonus if st.session_state.team_leader_bonus else 0,
+        # "other_bonus": st.session_state.electrical_bonus + st.session_state.painting_bonus + st.session_state.welding_bonus if st.session_state.electrical_bonus + st.session_state.painting_bonus + st.session_state.welding_bonus else 0,
+        "device_model": get_device_id(),
+        "device_ip": get_current_ip(),
+        "modified": dt.datetime.now(),
+    }
+    if 'completed_forms' not in st.session_state:
+        st.session_state['completed_forms'] = []
+    st.session_state.completed_forms.append(data_dict)
+    st.toast('Fiche de temps validée et enregistrée', icon="✅")
+
+def reset(df):
+    st.session_state.df = df
+    st.session_state.indexes_all = {k: 0 for k in df['all'].columns}
+    st.session_state.indexes_affaire = {k: 0 for k in df['affaire'].columns}
+    st.session_state.indexes_intervenants = {k: 0 for k in df['intervenants'].columns}
+    st.session_state.indexes_vehicules = {k: 0 for k in df['vehicules'].columns}
+
+
+    st.session_state.intervenant = df['intervenants'].intervenant[0]
+    st.session_state.client = df['affaire'].client[0]
+    st.session_state.affaire = df['affaire'].affaire[0]
+    st.session_state.prestataire = df['affaire'].prestataire[0]
+    st.session_state.vehicules = df['vehicules'].vehicules[0]
+
+    st.session_state.activities_text_area = ""
+
+    st.session_state.date_input = dt.datetime.now()
+    st.session_state.public_holyday = False
+    st.session_state.start_time_input = dt.time(8, 00)
+    st.session_state.end_time_input = dt.time(17, 00)
+
+    st.session_state.pause_time_input = dt.time(0, 00)
+    
+
+    st.session_state.supplement1 = df['supplements'].supplements[0]
+    st.session_state.supplement2 = df['supplements'].supplements[0]
+    st.session_state.supplement3 = df['supplements'].supplements[0]
+    st.toast('Nouvelle fiche de temps ', icon="🔃")
+
+async def run_async_tasks():
+    await read_transform_write_excel(form=st.session_state.completed_forms[-1])
+    st.toast('Mise à jour de votre historique, veuillez patienter', icon="💾")
+    historic_df = await update_historical_week(dropbox_datapath='/SEC_IND_GTP2023_OUTPUT', form=st.session_state.completed_forms[-1])
+    st.toast('Historique mis à jour', icon="✅")
+
+    st.toast('Mise à jour du Tableau de société, veuillez patienter', icon="💾")
+    society_form = generate_society_fit(form=st.session_state.completed_forms[-1])
+    society_df = await update_society_fit(dropbox_datapath='/SEC_IND_GTP2023_OUTPUT', form=society_form)
+    st.toast('Tableau de société mis à jour', icon="✅")
+
+    st.toast('Mise à jour des Prestations croisées, veuillez patienter', icon="💾")
+    society_form = generate_society_payroll(form=st.session_state.completed_forms[-1])
+    society_df = await update_society_payroll(dropbox_datapath='/SEC_IND_GTP2023_OUTPUT', form=society_form)
+    st.toast('Prestations croisées mis à jour', icon="✅")
+
+    st.toast('Mise à jour du Tableau de paye, veuillez patienter', icon="💾")
+    payroll = generate_intervenant_monthly_payroll(form=historic_df)
+    await update_monthly_payroll(dropbox_datapath='/SEC_IND_GTP2023_OUTPUT', payroll_dict=payroll, year=st.session_state.completed_forms[-1]['year'] , month=st.session_state.completed_forms[-1]['month'], week=st.session_state.completed_forms[-1]['week'])
+    st.toast('Tableau de paye mis à jour', icon="✅")
+    st.toast('Fiche de temps dupliquée', icon="📄")
+
+def validate_duplicate():
+    if st.session_state.intervenant != '-' and st.session_state.client != '-' and st.session_state.affaire != '-':
+        validate()
+        # print(st.session_state.completed_forms[-1])
+        if st.session_state.date_input < dt.datetime.now().date():
+            st.session_state.date_input += dt.timedelta(days=1)
+        
+        asyncio.run(run_async_tasks())
+
+    else:
+        st.toast('Veuillez remplir les champs intervenant, client et affaire', icon="⚠️")
+
+def validate_end():
+    if st.session_state.intervenant != '-' and st.session_state.client != '-' and st.session_state.affaire != '-':
+        validate()
+        
+        asyncio.run(run_async_tasks())
+
+        st.session_state.completed_forms = []
+        st.toast('Vous pouvez fermer l\'application ', icon="👍")
+    else:
+        st.toast('Veuillez remplir les champs intervenant, client et affaire', icon="⚠️")

utils/device.py

@@ -0,0 +1,11 @@
+import platform
+import socket
+
+def get_current_ip():
+    hostname = socket.gethostname()
+    ip_address = socket.gethostbyname(hostname)
+    return ip_address
+
+def get_device_id():
+    device_id = platform.node()
+    return device_id

utils/indemnites.py

@@ -0,0 +1,78 @@
+from typing import List
+import streamlit as st
+
+from utils.times import date_to_week_day, date_to_week_number
+
+def calculate_indemnites_km(indem_vehicles: List[str] = ['Perso']) -> (float, float):
+    location = st.session_state.location
+    vehicule = st.session_state.vehicules
+    prestataire = st.session_state.df['affaire'][st.session_state.df['affaire']['affaire'] == st.session_state.affaire]['prestataire'].values[0]
+    
+    if  st.session_state.intervenant == '-' \
+        or st.session_state.client == '-' \
+        or location == 'En Atelier' \
+        or not vehicule in indem_vehicles:
+        return 0, 0
+    else:
+        secteur = st.session_state.df['intervenants'][st.session_state.df['intervenants']['intervenant'] == st.session_state.intervenant]['secteur'].values[0]
+        distance = st.session_state.df['Clients'][(st.session_state.df['Clients']['Nom client'] == st.session_state.client) & (st.session_state.df['Clients']['Prestataire'] == prestataire)][f'Dist {secteur}'].values[0]
+        duration = st.session_state.df['Clients'][(st.session_state.df['Clients']['Nom client'] == st.session_state.client) & (st.session_state.df['Clients']['Prestataire'] == prestataire)][f'Duration {secteur}'].values[0]
+        
+        if distance * 2 < 35:
+            return 0, 0
+        indemnites = float(distance) * 2 * 0.35     
+        drive_hours = float(duration) * 2
+        indemnites = round(indemnites, 2)
+        hours, minutes = divmod(drive_hours, 60)
+        return indemnites, hours + (minutes / 60)
+
+def calculate_astreinte():
+    public_holyday = st.session_state.public_holyday
+    intervenant = st.session_state.intervenant
+    year = st.session_state.date_input.year
+    month = st.session_state.date_input.month
+    week = date_to_week_number(st.session_state.date_input)
+    if 'fit' in st.session_state.keys() and intervenant in st.session_state.fit.keys() and year in st.session_state.fit[intervenant].keys() and month in st.session_state.fit[intervenant][year].keys() and week in st.session_state.fit[intervenant][year][month].keys():
+        totals = st.session_state.fit[intervenant][year][month][week]['totals']
+        if totals['worked_hours'] >= st.session_state.contract_hours and st.session_state.contract_hours != 0:
+            if public_holyday:
+                return 321.0
+            return 321.0
+    return 0.0
+
+def calculate_overtimes():
+    overtime25, overtime50, overtime100 = 0., 0., 0.
+    intervenant = st.session_state.intervenant
+    year = st.session_state.date_input.year
+    month = st.session_state.date_input.month
+    week = date_to_week_number(st.session_state.date_input)
+    weekday = date_to_week_day(st.session_state.date_input)
+    hour_price = st.session_state.df['intervenants'][st.session_state.df['intervenants']['intervenant'] == st.session_state.intervenant]['cout horaire'].values[0]
+    if 'fit' in st.session_state.keys() and intervenant in st.session_state.fit.keys() and year in st.session_state.fit[intervenant].keys() and month in st.session_state.fit[intervenant][year].keys() and week in st.session_state.fit[intervenant][year][month].keys():
+        week_hours = st.session_state.fit[intervenant][year][month][week]['totals']['worked_hours']
+        if st.session_state.contract_hours != 0 and st.session_state.contract_hours < week_hours:
+            overtime25 = max(0, min(8, week_hours - 35))
+        if st.session_state.contract_hours != 0 and week_hours >= 43:
+            overtime50 = (week_hours - 43)
+        if weekday == 'samedi':
+            overtime50 = st.session_state.total_hours
+        if weekday == 'dimanche' or st.session_state.public_holyday:
+            overtime100 = st.session_state.total_hours
+    return overtime25, overtime50, overtime100
+
+def calculate_arrets():
+    secteur = st.session_state.df['intervenants'][st.session_state.df['intervenants']['intervenant'] == st.session_state.intervenant]['secteur'].values[0]
+    mask = st.session_state.df['absences'].applymap(lambda x: isinstance(x, str) and st.session_state.affaire.find(x) != -1)
+    mask = st.session_state.df['absences']['Libellé GTP2023'].apply(lambda x: st.session_state.affaire.find(x) != -1)
+    hr_code = st.session_state.df['absences'][mask]['Code_RH'].values[0]
+    contract_hours = st.session_state.contract_hours
+    if not contract_hours in [35., 37., 37.5, 39.]:
+        return 0
+    weekday = date_to_week_day(st.session_state.date_input)
+    weekday = 'JS_' if weekday != 'vendredi' else 'V_'
+    weekday = weekday if secteur == 'STE' else ''
+
+    am_values = st.session_state.df['arrets'][st.session_state.df['arrets']['code_absence'] == f'{hr_code}1_{weekday}{secteur}'][f'H-{float(contract_hours)}'].values
+    return am_values[0] if len(am_values) > 0 else 0
+
+    

utils/times.py

@@ -0,0 +1,56 @@
+from datetime import datetime, timedelta, time
+import locale
+from babel.dates import format_date, get_day_names
+
+locale.setlocale(locale.LC_ALL, 'fr_FR.UTF-8')
+
+def calculate_night_time(start_time: time, end_time: time, pause_time: time, date: datetime) -> float:
+    start_datetime = datetime.combine(date, start_time)
+    end_datetime = datetime.combine(date, end_time)
+
+    night_start = datetime.combine(date, datetime.strptime("21:00:00", "%H:%M:%S").time())
+    night_end = datetime.combine(date, datetime.strptime("06:00:00", "%H:%M:%S").time())    
+    night_worktime = timedelta()
+
+    if end_datetime < start_datetime :
+        end_datetime += timedelta(days=1)
+        night_end += timedelta(days=1)
+        night_worktime = min(end_datetime, night_end) - max(start_datetime, night_start)
+    else:
+        if end_datetime >= night_start:
+            night_worktime = max(end_datetime, night_end ) - max(start_datetime, night_start)
+            
+        else:
+            night_worktime = min(end_datetime, night_end) - min(start_datetime, night_start)
+    
+    night_worktime = max(night_worktime, timedelta())
+    pause_delta = timedelta(hours=pause_time.hour, minutes=pause_time.minute)
+    night_worktime -= pause_delta if night_worktime > pause_delta else night_worktime
+
+    total_seconds = night_worktime.total_seconds()
+    hours = float(total_seconds / 3600)
+
+    return hours
+
+def calculate_work_time(start_time: time, end_time: time, pause_time: time, date: datetime) -> float:
+    start_datetime = datetime.combine(date, start_time)
+    end_datetime = datetime.combine(date, end_time)
+    
+    if end_datetime < start_datetime:
+        end_datetime += timedelta(days=1)
+
+    worktime = end_datetime - start_datetime
+    pause_delta = timedelta(hours=pause_time.hour, minutes=pause_time.minute)
+    worktime -= pause_delta if worktime > pause_delta else worktime
+    
+    total_seconds = worktime.total_seconds()
+    hours = float(total_seconds / 3600)
+    return hours
+
+def date_to_week_number(date: datetime) -> int:
+    return date.isocalendar()[1]
+
+def date_to_week_day(date: datetime) -> int:
+    # weekday_english = date.strftime("%A")
+    weekday_french = format_date(date, 'EEEE', locale='fr')
+    return weekday_french