**Add scheduling and publishing flags and update app.py**

- Introduce flags for various actions in `functi.py` to manage state and ensure thread safety.
- Update `app.py` to include a new flag `has_navigated` and adjust logging configuration.
- Enhance the `add_scheduling` function to handle scheduling with improved time management and database interactions.
- Modify the post publishing function to include a reset mechanism for the publishing flag using a timer.
- Ensure the code is more robust and maintainable with clear state management.

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "taipyStudio.gUI.elementsFilePaths": []
+}

app.py

@@ -8,10 +8,11 @@ from flask import Flask, request
 from urllib.parse import urlparse, parse_qs
 import time
 import logging
+
 logging.getLogger('requests_oauthlib').setLevel(logging.DEBUG)
 
 mssage_callback = "Authentification success, close this tabs and return to the login page"
-
+has_navigated = False
 
 import requests
 

functi.py

@@ -21,6 +21,21 @@ from apscheduler.triggers.cron import CronTrigger
 apsched = BackgroundScheduler()
 apsched.start()
 
+# Create flags for each action
+has_on_my_clicking = False
+has_add_source = False
+has_authen = False
+has_post_generation = False
+has_post_publishing = False
+has_add_scheduling = False
+has_on_login = False
+has_on_register = False
+has_on_logout = False
+has_toggle_register = False
+has_delete_account = False
+has_delete_schedule = False
+has_delete_source = False
+
 Linked_account_name = " "
 Linked_social_network = " "
 data_schedule ={}
@@ -194,10 +209,34 @@ def planifier_ligne(id_schedule, id_social, user_id, schedule_time_str, ss, adju
 
 def add_scheduling(state):
     """Add new scheduling with thread safety"""
-    try:
-        if isinstance(state.day_value, list):
-            for day in state.day_value:
-                timesche = f"{day} {int(state.time_value_hour)}:{int(state.time_value_minute)}"
+    if not state.has_add_scheduling:
+        state.has_add_scheduling = True
+        try:
+            if isinstance(state.day_value, list):
+                for day in state.day_value:
+                    timesche = f"{day} {int(state.time_value_hour)}:{int(state.time_value_minute)}"
+
+                    # Get current schedule
+                    df = db_manager.fetch_schedule_table()
+
+                    if not df.empty:
+                        df, final_time = add_request(df, timesche)
+                    else:
+                        jour, horaire = timesche.split()
+                        horaire = horaire.replace(';', ':')
+                        h, m = map(int, horaire.split(':'))
+                        m -= 7  # 7 minutes before for generation
+                        final_time = f"{jour} {h}:{m:02d}"
+
+                    # Add to database
+                    db_manager.create_scheduling_for_user(
+                        state.user_inf.user.id,
+                        state.Linked_social_network,
+                        timesche,
+                        final_time
+                    )
+            else:
+                timesche = f"{state.day_value} {int(state.time_value_hour)}:{int(state.time_value_minute)}"
 
                 # Get current schedule
                 df = db_manager.fetch_schedule_table()
@@ -218,40 +257,25 @@ def add_scheduling(state):
                     timesche,
                     final_time
                 )
-        else:
-            timesche = f"{state.day_value} {int(state.time_value_hour)}:{int(state.time_value_minute)}"
 
-            # Get current schedule
+            # Refresh the schedule after adding
             df = db_manager.fetch_schedule_table()
+            state.data_schedule = db_manager.fetch_schedule_table_acc(state.user_inf.user.id)
 
-            if not df.empty:
-                df, final_time = add_request(df, timesche)
-            else:
-                jour, horaire = timesche.split()
-                horaire = horaire.replace(';', ':')
-                h, m = map(int, horaire.split(':'))
-                m -= 7  # 7 minutes before for generation
-                final_time = f"{jour} {h}:{m:02d}"
-
-            # Add to database
-            db_manager.create_scheduling_for_user(
-                state.user_inf.user.id,
-                state.Linked_social_network,
-                timesche,
-                final_time
-            )
-
-        # Refresh the schedule after adding
-        df = db_manager.fetch_schedule_table()
-        state.data_schedule = db_manager.fetch_schedule_table_acc(state.user_inf.user.id)
-
-        # Reschedule all tasks
-        replanifier_toutes_les_tâches(df)
+            # Reschedule all tasks
+            replanifier_toutes_les_tâches(df)
 
-        print(f"✅ Scheduling added successfully", flush=True)
+            print(f"✅ Scheduling added successfully", flush=True)
 
-    except Exception as e:
-        print(f"❌ Error in add_scheduling: {e}", flush=True)
+        except Exception as e:
+            print(f"❌ Error in add_scheduling: {e}", flush=True)
+
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_add_scheduling = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
 
 def planning():
     df = db_manager.fetch_schedule_table()
@@ -259,188 +283,295 @@ def planning():
         replanifier_toutes_les_tâches(df)
 
 def post_publishing(state) :
+    if not state.has_post_publishing:
+        state.has_post_publishing = True
 
-    resp = db_manager.fetching_user_identif(state.user_inf.user.id,state.social_network)
-    data = pd.DataFrame(resp.data)
+        resp = db_manager.fetching_user_identif(state.user_inf.user.id,state.social_network)
+        data = pd.DataFrame(resp.data)
 
-    first = data[data['social_network'] == state.social_network].iloc[0]
-    token_value = first["token"]
-    sub_value = first["sub"]
+        first = data[data['social_network'] == state.social_network].iloc[0]
+        token_value = first["token"]
+        sub_value = first["sub"]
 
-    url = "https://api.linkedin.com/v2/ugcPosts"
-    headers = {
-        "Authorization": f"Bearer {token_value}",
-        "X-Restli-Protocol-Version": "2.0.0",
-        "Content-Type": "application/json"
-    }
-    body = {
-        "author": f"urn:li:person:{sub_value}",
-        "lifecycleState": "PUBLISHED",
-        "specificContent": {
-            "com.linkedin.ugc.ShareContent": {
-                "shareCommentary": {
-                    "text": state.generated_post
-                },
-                "shareMediaCategory": "NONE"
+        url = "https://api.linkedin.com/v2/ugcPosts"
+        headers = {
+            "Authorization": f"Bearer {token_value}",
+            "X-Restli-Protocol-Version": "2.0.0",
+            "Content-Type": "application/json"
+        }
+        body = {
+            "author": f"urn:li:person:{sub_value}",
+            "lifecycleState": "PUBLISHED",
+            "specificContent": {
+                "com.linkedin.ugc.ShareContent": {
+                    "shareCommentary": {
+                        "text": state.generated_post
+                    },
+                    "shareMediaCategory": "NONE"
+                }
+            },
+            "visibility": {
+                "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"
             }
-        },
-        "visibility": {
-            "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"
         }
-    }
 
-    resp = requests.post(url, headers=headers, json=body)
-    print([resp.status_code, resp.text],flush = True)
+        resp = requests.post(url, headers=headers, json=body)
+        print([resp.status_code, resp.text],flush = True)
+
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_post_publishing = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
 
 def post_generation(state) :
-    state.generated_post = client.predict(
-        code=state.user_inf.user.id,
-		api_name="/poster_linkedin"
-)
+    if not state.has_post_generation:
+        state.has_post_generation = True
+        state.generated_post = client.predict(
+            code=state.user_inf.user.id,
+            api_name="/poster_linkedin"
+        )
+
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_post_generation = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
 
 def authen(state) :
-    if state.Linked_social_network == "Linkedin" :
-        print("jhdijb",flush = True)
-        state.urlss, state.states = linkedin.authorization_url(
-        'https://www.linkedin.com/oauth/v2/authorization'
-    )
+    if not state.has_authen:
+        state.has_authen = True
+        if state.Linked_social_network == "Linkedin" :
+            print("jhdijb",flush = True)
+            state.urlss, state.states = linkedin.authorization_url(
+            'https://www.linkedin.com/oauth/v2/authorization'
+        )
         navigate(state, state.urlss)
 
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_authen = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
+
 def on_my_clicking(state, action, payload) :
-    print(action,flush = True)
-    print(payload["args"][0],flush = True)
-    if payload["args"][0] == "Accueil" :
-        on_logout(state)
-    navigate(state, payload["args"][0])
+    if not state.has_on_my_clicking:
+        state.has_on_my_clicking = True
+        print(action,flush = True)
+        print(payload["args"][0],flush = True)
+        if payload["args"][0] == "Accueil" :
+            on_logout(state)
+        navigate(state, payload["args"][0])
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_on_my_clicking = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
 
     return " "
 
 def add_source(state) :
+    if not state.has_add_source:
+        state.has_add_source = True
 
-    result = client.predict(
-            rss_link=state.source_ + "__thi_irrh'èçs_my_id__! "+state.user_inf.user.id,
-            api_name="/ajouter_rss"
-    )
+        result = client.predict(
+                rss_link=state.source_ + "__thi_irrh'èçs_my_id__! "+state.user_inf.user.id,
+                api_name="/ajouter_rss"
+        )
 
-    state.source_add_message = result
-    data = db_manager.fetch_source_table(state.user_inf.user.id)
-    state.Source_table = pd.DataFrame(data)
+        state.source_add_message = result
+        data = db_manager.fetch_source_table(state.user_inf.user.id)
+        state.Source_table = pd.DataFrame(data)
 
-def delete_source(state, var_name: str, payload: dict) :
-    state.Source_table_before = state.Source_table
-    state.get_gui().table_on_delete(state, var_name, payload)
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_add_source = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
 
-    diff = state.Source_table_before.merge(state.Source_table, how="outer", indicator=True) \
-          .query('_merge != "both"') \
-          .drop(columns='_merge')
-    valeurs = diff['id'].tolist()
-    db_manager.delete_from_table("Source",valeurs)
+def delete_source(state, var_name: str, payload: dict) :
+    if not state.has_delete_source:
+        state.has_delete_source = True
+        state.Source_table_before = state.Source_table
+        state.get_gui().table_on_delete(state, var_name, payload)
+
+        diff = state.Source_table_before.merge(state.Source_table, how="outer", indicator=True) \
+              .query('_merge != "both"') \
+              .drop(columns='_merge')
+        valeurs = diff['id'].tolist()
+        db_manager.delete_from_table("Source",valeurs)
+
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_delete_source = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
 
 def delete_account(state, var_name: str, payload: dict) :
-    state.data_account_before = state.data_account
-    state.get_gui().table_on_delete(state, var_name, payload)
-
-    diff = state.data_account_before.merge(state.data_account, how="outer", indicator=True) \
-          .query('_merge != "both"') \
-          .drop(columns='_merge')
-    valeurs = diff['id'].tolist()
-    db_manager.delete_from_table("Social_network",valeurs)
+    if not state.has_delete_account:
+        state.has_delete_account = True
+        state.data_account_before = state.data_account
+        state.get_gui().table_on_delete(state, var_name, payload)
+
+        diff = state.data_account_before.merge(state.data_account, how="outer", indicator=True) \
+              .query('_merge != "both"') \
+              .drop(columns='_merge')
+        valeurs = diff['id'].tolist()
+        db_manager.delete_from_table("Social_network",valeurs)
+
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_delete_account = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
 
 def delete_schedule(state, var_name: str, payload: dict) :
-    state.data_schedule_before = state.data_schedule
-    state.get_gui().table_on_delete(state, var_name, payload)
-
-    diff = state.data_schedule_before.merge(state.data_schedule, how="outer", indicator=True) \
-          .query('_merge != "both"') \
-          .drop(columns='_merge')
-    valeurs = diff['id'].tolist()
-    db_manager.delete_from_table("Scheduling",valeurs)
+    if not state.has_delete_schedule:
+        state.has_delete_schedule = True
+        state.data_schedule_before = state.data_schedule
+        state.get_gui().table_on_delete(state, var_name, payload)
+
+        diff = state.data_schedule_before.merge(state.data_schedule, how="outer", indicator=True) \
+              .query('_merge != "both"') \
+              .drop(columns='_merge')
+        valeurs = diff['id'].tolist()
+        db_manager.delete_from_table("Scheduling",valeurs)
+
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_delete_schedule = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
 
 def on_login(state, payload):
     """Handle login form submission"""
-    time.sleep(0.7)
-    email = state.login_email
-    password = state.login_password
-
-    if not email or not password:
-        state.message = "Please enter both email and password"
-        return
-
-    success, message, user_inf = db_manager.authenticate_user(email, password)
-
-    if user_inf is None:
-        # Handle the case when authentication fails
-        state.message = message
-        return
-
-    if success:
-        state.current_user = email
-        data = db_manager.fetch_source_table(user_inf.user.id)
-        dataac = db_manager.fetch_account_table(user_inf.user.id)
-        state.data_schedule = db_manager.fetch_schedule_table_acc(user_inf.user.id)
-        state.data_account = pd.DataFrame(dataac)
-        state.Source_table = pd.DataFrame(data)
-        navigate(state, "Source_Management")
-        state.is_logged_in = True
-        state.message = f"Welcome back, {email}!"
-        # Clear form
-        state.login_email = ""
-        state.login_password = ""
-    else:
-        if message == "Compte non confirmé":
-            state.message = "Votre compte n'est pas encore activé. Veuillez vérifier votre email pour activer votre compte."
-        elif message == "Compte non existant":
-            state.message = "Email ou mot de passe incorrect."
+    if not state.has_on_login:
+        state.has_on_login = True
+        time.sleep(0.7)
+        email = state.login_email
+        password = state.login_password
+
+        if not email or not password:
+            state.message = "Please enter both email and password"
+            return
+
+        success, message, user_inf = db_manager.authenticate_user(email, password)
+
+        if user_inf is None:
+            # Handle the case when authentication fails
+            state.message = message
+            return
+
+        if success:
+            state.current_user = email
+            data = db_manager.fetch_source_table(user_inf.user.id)
+            dataac = db_manager.fetch_account_table(user_inf.user.id)
+            state.data_schedule = db_manager.fetch_schedule_table_acc(user_inf.user.id)
+            state.data_account = pd.DataFrame(dataac)
+            state.Source_table = pd.DataFrame(data)
+            navigate(state, "Source_Management")
+            state.is_logged_in = True
+            state.message = f"Welcome back, {email}!"
+            # Clear form
+            state.login_email = ""
+            state.login_password = ""
         else:
-            state.message = "Email ou mot de passe incorrect."
+            if message == "Compte non confirmé":
+                state.message = "Votre compte n'est pas encore activé. Veuillez vérifier votre email pour activer votre compte."
+            elif message == "Compte non existant":
+                state.message = "Email ou mot de passe incorrect."
+            else:
+                state.message = "Email ou mot de passe incorrect."
+
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_on_login = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
 
 def on_register(state):
     """Handle registration form submission"""
-    time.sleep(0.7)
-    email = state.register_email
-    password = state.register_password
-    confirm_password = state.confirm_password
+    if not state.has_on_register:
+        state.has_on_register = True
+        time.sleep(0.7)
+        email = state.register_email
+        password = state.register_password
+        confirm_password = state.confirm_password
+
+        if not email or not password or not confirm_password:
+            state.message = "Please fill in all fields"
+            return
+
+        if password != confirm_password:
+            state.message = "Passwords do not match"
+            return
+
+        if len(password) < 8:
+            state.message = "Password must be at least 8 characters long"
+            return
+
+        success, message,user_inf = db_manager.create_user(email, password) # type: ignore
+
+        if success:
+            state.message = "Un lien d'activation a été envoyé à votre adresse email. Veuillez vérifier votre boîte de réception pour activer votre compte."
+            state.show_register = False
+            # Clear form
+            state.register_email = ""
+            state.register_password = ""
+            state.confirm_password = ""
+        else:
+            state.message = message or "Erreur lors de l'inscription. Veuillez réessayer."
 
-    if not email or not password or not confirm_password:
-        state.message = "Please fill in all fields"
-        return
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_on_register = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
 
-    if password != confirm_password:
-        state.message = "Passwords do not match"
-        return
+def on_logout(state):
+    if not state.has_on_logout:
+        state.has_on_logout = True
 
-    if len(password) < 8:
-        state.message = "Password must be at least 8 characters long"
-        return
+        """Handle logout"""
 
-    success, message,user_inf = db_manager.create_user(email, password) # type: ignore
+        state.current_user = None
+        state.is_logged_in = False
+        state.message = "Logged out successfully"
+        state.login_email = ""
+        state.login_password = ""
 
-    if success:
-        state.message = "Un lien d'activation a été envoyé à votre adresse email. Veuillez vérifier votre boîte de réception pour activer votre compte."
-        state.show_register = False
-        # Clear form
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_on_logout = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()
+
+def toggle_register(state):
+    """Toggle between login and register forms"""
+    if not state.has_toggle_register:
+        state.has_toggle_register = True
+        state.show_register = not state.show_register
+        state.message = ""
+        state.login_email = ""
+        state.login_password = ""
         state.register_email = ""
         state.register_password = ""
         state.confirm_password = ""
-    else:
-        state.message = message or "Erreur lors de l'inscription. Veuillez réessayer."
-
-def on_logout(state):
 
-    """Handle logout"""
-
-    state.current_user = None
-    state.is_logged_in = False
-    state.message = "Logged out successfully"
-    state.login_email = ""
-    state.login_password = ""
-
-def toggle_register(state):
-    """Toggle between login and register forms"""
-    state.show_register = not state.show_register
-    state.message = ""
-    state.login_email = ""
-    state.login_password = ""
-    state.register_email = ""
-    state.register_password = ""
-    state.confirm_password = ""
+        # Programmer la réinitialisation du flag dans 2 secondes
+        def reset_flag():
+            state.has_toggle_register = False
+        timer = threading.Timer(2.0, reset_flag)
+        timer.daemon = True   # permet de ne pas bloquer la fermeture de l’app
+        timer.start()