Upload 11 files

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.11
+
+
+WORKDIR /app
+
+COPY ./ /app
+
+RUN pip install -r requirements.txt
+
+CMD python app.py

Post_management.py

@@ -0,0 +1,40 @@
+from taipy import Gui
+import taipy.gui.builder as tgb
+from functi import post_generation,post_publishing,authen,add_scheduling,delete_account,delete_schedule
+
+days_of_week = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+Social_network_menu = ["Linkedin"]
+
+with tgb.Page(class_name="bodyp") as Post_manag :
+    with tgb.part(class_name="source_body") :
+        tgb.text("Post Managements ",class_name="Title_Page")
+        with tgb.part(class_name="layout_top") :
+            tgb.text("Linking Account",class_name="header-burgundy")            
+            with tgb.layout(columns="2fr 1",class_name="table_t") :
+                with tgb.part() :
+                    with tgb.layout(columns="1 1 1") :
+                        tgb.input("{Linked_account_name}" ,label ="Choose an account name",change_delay = -1,action_on_blur = True)
+                        tgb.selector("{Linked_social_network}", lov=Social_network_menu,dropdown=True) # type: ignore    
+                        tgb.button(label = "Add account", on_action = authen)
+                    tgb.table("{data_account}",editable = True, on_add = False,on_edit = False,on_delete = delete_account,columns="social_network;account_name")
+        with tgb.part(class_name="table_s") :   
+            tgb.text("Demo",class_name="header-burgundy table_t")
+            tgb.button(label = "Generate a post",on_action = post_generation)
+            tgb.text("{generated_post}",mode = "pre",class_name="burgundy-border",width= "45%")
+            tgb.button(label = "Publish", on_action = post_publishing)
+        with tgb.part(class_name="table_s") :
+            tgb.text("Post Scheduling",class_name="header-burgundy")
+            with tgb.layout(columns = "3fr 1", class_name="table_t"  ) :
+                with tgb.layout( columns="1 1 1 1") :
+                    tgb.input("{time_value_hour}",label = "Hour",change_delay = -1,action_on_blur = True)
+                    tgb.input("{time_value_minute}",label = "Minute",change_delay = -1,action_on_blur = True)
+                    tgb.selector("{day_value}", lov=days_of_week,multiple = True,dropdown=True,show_select_all=True) # type: ignore
+                    tgb.button(label = "Add",on_action = add_scheduling)
+                tgb.text("")
+                tgb.table("{data_schedule}",editable = True, on_add = False,on_edit = False,on_delete = delete_schedule,class_name="table_t")
+
+            
+            # Date complète
+            # tgb.date("{day_value}", format="EEEE, MMM dd, yyyy", label="Full Date with Day")
+            
+        

Post_robot.py

@@ -0,0 +1,26 @@
+# import schedule
+# import threading
+# import time
+# import datetime
+# from functi import db_manager,add_scheduling,planning
+
+
+
+
+# def background_scheduler():
+#      while True:
+#         try:
+#             schedule.run_pending()
+#         except Exception as e:
+#             print("Erreur dans run_pending():", e, flush=True)
+#         time.sleep(1)
+
+
+# thread = threading.Thread(target=background_scheduler)
+# thread.start()
+# print("it actually worked")
+# threading.Thread(target=planning, daemon=True).start()
+
+
+    
+    

Source_manage.css

@@ -0,0 +1,6 @@
+.source_body{
+    margin: 4em;
+    padding: 18em;
+    background-color: #ECF4F7;
+    
+}

Source_manage.py

@@ -0,0 +1,26 @@
+from taipy import Gui
+import taipy.gui.builder as tgb
+from functi import add_source, delete_source,on_logout,on_my_clicking
+
+
+
+with tgb.Page() as menu_page: # type: ignore
+    with tgb.part(render = "{is_logged_in}", id="taipy_menu") : # type: ignore
+        tgb.menu(lov=[
+        ("Source_Management", "Sources"),("Post", "Post Management"),("Accueil", "Logging Out")
+    ],
+        on_action = on_my_clicking,width = "20vw")
+        
+with tgb.Page() as source_page: # type: ignore
+    with tgb.part(class_name="source_body") :
+        tgb.text("Source Managements",class_name="Title_Page")
+        with tgb.layout(columns="4fr 1",class_name="layout_top") :
+            with tgb.part() :
+                with tgb.layout(columns="1 1") :
+                    tgb.input("{source_}" ,label ="Source",change_delay = -1,action_on_blur = True,class_name="fullwidth ")
+                    tgb.button("Add", on_action = add_source)
+        with tgb.part(class_name="table_s") :
+            tgb.text("Liste des sources")
+            tgb.table("{Source_table}",columns="source;categorie;last_update",editable = True, on_add = False,on_edit = False,on_delete = delete_source,class_name="header-plain table_t")
+
+

app.css

@@ -0,0 +1,134 @@
+/* 📦 1. Importer la police Pacifico */
+@import url('https://fonts.googleapis.com/css2?family=Pacifico&display=swap');
+
+/* 2. Réinitialisation globale */
+div#root{
+  margin: 0rem !important;
+}
+
+.header-burgundy {
+  color: #39404B; /* Burgundy */
+  font-weight: bold;
+  font-size: 1em;
+  margin-bottom: 0.5em;
+}
+
+.burgundy-border {
+  border: 2px solid #800020; /* Burgundy border */
+  color: #800020;            /* Burgundy text */
+  border-radius: 6px;
+  padding: 0.5em 1em;
+}
+
+.source_body{
+  margin: 2em;
+  background-color: #ECF4F7;
+    
+}
+
+.layout_top {
+    padding-top: 5em;
+}
+
+
+.css-w1lhxi{
+  /* --color-background-light: #910029; */
+  background-color: #910029 ;
+  color: aliceblue;
+}
+
+.table_s{
+  padding-top: 2em;
+}
+.table_t{
+  padding-top: 1.3em;
+}
+
+.Title_Page { 
+  font-weight: bold; 
+  font-size: 2em; 
+  color: #39404B;
+  display: block;
+  box-sizing: border-box;
+  position: relative; width: 100%; } 
+  .Title_Page::after { 
+    content: ''; 
+  position: absolute;
+   bottom: -8px; left: 0; 
+   width: 100%; 
+   height: 3px; 
+   background-color: #39404B; }
+
+html, body {
+  margin: 0;
+  padding: 0;
+  height: 100%;
+}
+
+.bodyp{
+  margin: 0;
+  padding: 0;
+}
+
+/* 3. Partie .presentation sans aucun padding */
+.presentation {
+  margin: 0;
+  padding: 0;
+  height: 100vh;
+  width: 100%;
+  position: relative;
+  background-image:
+    linear-gradient(rgba(0, 0, 0, 0.5), rgba(0, 0, 0, 0.5)),
+    url("src/image/20250715_1931_Digital Workspace Dashboard_remix_01k07nha1pfn1sas0rkdrt7sj0.webp");
+  background-size: cover;
+  background-position: center;
+  color: white;
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  align-items: center;
+  font-family: sans-serif;
+}
+
+/* 4. Nom de l’app en haut à gauche, stylé Pacifico */
+.App_name {
+  position: absolute;
+  top: 20px;
+  left: 30px;
+  font-size: 2.5em;
+  font-family: 'Pacifico', cursive;
+  z-index: 2;
+}
+
+/* 5. Texte de présentation avec effet elevated au survol */
+.presentation_text {
+  position: relative;
+  z-index: 2;
+  text-align: center;
+  font-size: 2em;
+  padding: 20px 30px;
+  max-width: 80%;
+  background: rgba(255, 255, 255, 0.1);
+  border-radius: 8px;
+  transition: transform 0.3s ease, background 0.3s ease, box-shadow 0.3s ease;
+}
+.presentation_text:hover {
+  background: rgba(255, 255, 255, 0.15);
+  transform: translateY(-5px) scale(1.02);
+  box-shadow:
+    0 10px 20px rgba(0, 0, 0, 0.25),
+    0 0 15px rgba(255, 255, 255, 0.6);
+}
+
+/* 6. Responsive */
+@media (max-width: 768px) {
+  .App_name {
+    font-size: 1.8em;
+    top: 15px;
+    left: 20px;
+  }
+  .presentation_text {
+    font-size: 1.3em;
+    padding: 15px 20px;
+  }
+}

app.py

@@ -0,0 +1,178 @@
+from taipy import Gui
+from taipy.gui import navigate # type: ignore
+import taipy.gui.builder as tgb
+from functi import *
+from Source_manage import source_page, menu_page
+from Post_management import Post_manag
+from flask import Flask, request
+from urllib.parse import urlparse, parse_qs
+import time
+import logging
+logging.getLogger('requests_oauthlib').setLevel(logging.DEBUG)
+
+
+import requests
+
+def obtenir_access_token(code, client_id, client_secret, redirect_uri):
+    url = "https://www.linkedin.com/oauth/v2/accessToken"
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded"
+    }
+    data = {
+        "grant_type": "authorization_code",
+        "code": code,
+        "redirect_uri": redirect_uri,
+        "client_id": client_id,
+        "client_secret": client_secret
+    }
+
+    response = requests.post(url, headers=headers, data=data)
+    response.raise_for_status()  # lève une exception si le statut HTTP n’est pas 2xx
+    return response.json()
+
+
+# Presentation text
+presentation_text = """
+Découvrez Lin votre assistant community manager sur Linkedin
+"""
+
+
+
+
+
+def on_navigate(state, page_name: str):
+    if page_name == "callback":
+        raw = request.environ.get("REQUEST_URI", "")
+      
+    
+        full = request.scheme + "://" + request.host + raw
+        state.authorization_url = full
+        state.authorization_url = state.authorization_url.replace("/taipy-jsx", "")
+        state.authorization_url = state.authorization_url.rsplit("&v", 1)[0]
+        state.authorization_url = state.authorization_url.replace("http://", "https://")
+        print(state.authorization_url,flush = True)
+        parsed = urlparse(state.authorization_url)
+
+        # 2. Extrait les paramètres dans un dict (valeur encapsulée dans une liste)
+        params = parse_qs(parsed.query)
+        
+        # 3. Récupère la valeur de state
+        state_value = params.get("state", [""])[0]
+        code = params.get("code", [""])[0]
+        print(state_value,flush = True)
+        print(state.states,flush = True)
+        print(code,flush = True)
+        if state_value.endswith('?'):
+            state_value = state_value[:-1]
+        else:
+            state_value = state_value
+        
+        if state_value == state.states :
+            if state.Linked_social_network == "Linkedin" :
+                response = obtenir_access_token(code, state.client_id, state.client_secret, state.redirect_url)
+                
+                state.token = response["access_token"]
+                
+                
+                url = "https://api.linkedin.com/v2/userinfo"
+                headers = {
+                    "Authorization": f"Bearer {state.token}"
+                }
+                
+                response_open = requests.get(url, headers=headers)
+                response_open =response_open.json()
+                db_manager.add_token_network(state.token,state.Linked_social_network,state.Linked_account_name,state.user_inf.user.id,response_open)
+                navigate(state,"Source_Management" )
+
+                
+                print(state.token,flush = True)
+            else :
+                print("mkjgfzmfvhsmehk")
+
+
+            
+    return page_name
+
+
+
+
+
+
+
+
+    
+
+with tgb.Page(class_name="bodyp") as callb:
+    tgb.text("attendez un moment")
+
+# Create pages
+with tgb.Page(class_name="bodyp") as page_appart:
+    
+    # Show login/register forms if not logged in
+    with tgb.part(render="{not is_logged_in}"): # type: ignore
+        with tgb.part(class_name="presentation", height="100vh"):
+            tgb.text("Lin", class_name="App_name")
+            
+            
+            with tgb.part(class_name="presentation_text"):
+                tgb.text(presentation_text, id="presentation_text_t")
+                with tgb.part(class_name="auth-container"):
+                    
+                    
+                    # Login form (default)
+                    with tgb.part(render="{not show_register}"):  # type: ignore
+                        tgb.text("Login to Lin")
+                        tgb.input("{login_email}", label="Email", type="email",change_delay = -1,action_on_blur = True)
+                        tgb.input("{login_password}", label="Password", password=True,change_delay = -1,action_on_blur = True)
+                        tgb.button("Login", on_action=on_login )
+                        tgb.button("Need an account? Register", on_action=toggle_register)
+                    
+                    # Register form
+                    with tgb.part(render="{show_register}"): # type: ignore
+                        tgb.text("Register for Lin", )
+                        tgb.input("{register_email}", label="Email", type="email",change_delay = -1,action_on_blur = True)
+                        tgb.input("{register_password}", label="Password", password=True,change_delay = -1,action_on_blur = True)
+                        tgb.input("{confirm_password}", label="Confirm Password", password=True,change_delay = -1,action_on_blur = True)
+                        tgb.button("Register", on_action=on_register, class_name="auth-button")
+                        tgb.button("Already have an account? Login", on_action=toggle_register, )
+                    
+                    # Message display
+                    with tgb.part(render="{message}"): # type: ignore
+                        tgb.text("{message}", class_name="message")
+    
+    # Show main content if logged in
+    with tgb.part(render="{is_logged_in}"): # type: ignore
+        with tgb.part(class_name="presentation", height="100vh"):
+            tgb.text("Lin", class_name="App_name")
+            tgb.text(f"Welcome, {'{current_user}'}!", class_name="welcome-message")
+            tgb.button("Logout", on_action=on_logout, class_name="logout-button")
+            
+            with tgb.part(class_name="presentation_text"):
+                tgb.text(presentation_text, id="presentation_text_t")
+
+# Define pages
+pages = {
+    "Accueil": page_appart,
+    "/": menu_page,
+    "Source_Management" : source_page,
+    "callback" : callb,
+    "Post" : Post_manag
+}
+
+stylekit = {
+  "color_primary" : "#910029",
+  
+}
+
+if __name__ == "__main__":
+    planning()
+
+    gui = Gui(pages=pages)
+    gui.run(
+        debug=True,
+        port=7860,host = "0.0.0.0",
+        stylekit=stylekit,
+        title="Lin",
+        dark_mode=False,
+        use_reloader=True
+    )

functi.py

@@ -0,0 +1,473 @@
+import hashlib
+import secrets
+from http.server import BaseHTTPRequestHandler, HTTPServer
+import threading
+import os
+import time 
+import datetime
+from line_db import DatabaseManager
+from urllib.parse import urlencode
+from taipy.gui import navigate # type: ignore
+from gradio_client import Client
+import pandas as pd
+from requests_oauthlib import OAuth2Session
+import requests
+
+from timing_lin import *
+from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.triggers.cron import CronTrigger
+
+# Create the scheduler globally (start it once)
+apsched = BackgroundScheduler()
+apsched.start()
+
+
+
+Linked_account_name = " "
+Linked_social_network = " "
+data_schedule ={}
+
+scope = ['openid', 'profile', 'email', 'w_member_social']
+
+time_value_hour = 18
+time_value_minute = 00
+day_value = "Monday"
+Linked_social_network  = "Linkedin"
+
+
+api_key_hugging = os.environ.get("hugging_key")
+Source_table = {}
+data_account = {}
+data_schedule = {}
+data_schedule_before = {}
+Source_table_before = {}
+data_account_before = {}
+
+url: str = os.environ.get("SUPABASE_URL") # type: ignore
+key: str = os.environ.get("SUPABASE_KEY") # type: ignore
+is_logged_in = False
+current_user = None
+message= ''
+show_register= False
+login_email= ''
+login_password= ''
+register_email= ''
+register_password= ''
+confirm_password= ''
+source_ = " "
+source_add_message = " "
+user_inf = " "
+generated_post = "test"
+token = " "
+authorization_url = " "
+urlss = ""
+states = ""
+social_network = "Linkedin"
+
+
+db_manager = DatabaseManager(url,key)
+client = Client("Zelyanoth/Linkedin_poster_dev",hf_token = api_key_hugging)
+
+client_id = os.environ.get("CLIENT_ID")
+redirect_url = os.environ.get("RED_URL")
+client_secret = os.environ.get("CLIENT_SECRET")
+
+
+
+linkedin = OAuth2Session(client_id, redirect_uri=redirect_url, scope=scope)
+
+
+
+
+
+def replanifier_toutes_les_tâches(df):
+     # Efface toutes les anciennes tâches
+    df.apply(
+        lambda r: planifier_ligne(r["id"],r["id_social"], r["user_id"], r["schedule_time"],r["social_network"],r["adjusted_time"]),
+        axis=1
+    )
+
+def post_generation_for_robot(id,social,idd) :
+    try :
+        print("⏳ Tâche planifizzzzzzzzzzzzzzzée pour",flush = True)
+        generated_post = client.predict(
+            code=id,
+    		api_name="/poster_linkedin"
+        
+)
+        db_manager.add_post(social,generated_post,idd)
+    except Exception as e:
+            print("Erreur dans gen():", e, flush=True)
+    
+
+
+def post_publishing_for_robot(id_social,id_user,idd,ss) :
+    try :
+        print("⏳ Tâche planifiée pour post_pubsih",flush = True)
+        resp = db_manager.fetching_user_identif(id_user,ss)
+        dd = db_manager.fetching_post(id_social,idd)
+        data = pd.DataFrame(resp.data)
+        print(data)
+        first = data[data['id'] == id_social].iloc[0]
+        token_value = first["token"]
+        sub_value = first["sub"]
+        post = dd["Text_content"].iloc[0]
+
+        print("⏳ Tâche planifiée pour gfjfxd",flush = True)
+        
+        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": post
+                    },
+                    "shareMediaCategory": "NONE"
+                }
+            },
+            "visibility": {
+                "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"
+            }
+        }
+        resp = requests.post(url, headers=headers, json=body)
+        db_manager.update_post(id_social,idd)
+        print([resp.status_code, resp.text],flush = True)
+    except Exception as e:
+            print("Erreur dans post():", e, flush=True)
+    
+
+    
+    
+  
+
+def planifier_ligne(id_schedule, id_social, user_id, schedule_time_str, ss, adjusted_time):
+    # Parse schedule_time_str and adjusted_time
+    parts = schedule_time_str.strip().split()
+    part_adj = adjusted_time.strip().split()
+    if len(parts) != 2 or ':' not in parts[1]:
+        print(f"❌ Format invalide : {schedule_time_str}", flush=True)
+        return
+    if len(part_adj) != 2 or ':' not in part_adj[1]:
+        print(f"❌ Format invalide : {adjusted_time}", flush=True)
+        return
+
+    jour, hm = parts
+    jour_adj, hm_adj = part_adj
+
+    try:
+        hour, minute = map(int, hm.split(':'))
+        hour_adj, minute_adj = map(int, hm_adj.split(':'))
+    except ValueError:
+        print(f"❌ Heure invalide : {hm}", flush=True)
+        return
+
+    # Map day names to APScheduler format
+    day_map = {
+        "monday": "mon",
+        "tuesday": "tue",
+        "wednesday": "wed",
+        "thursday": "thu",
+        "friday": "fri",
+        "saturday": "sat",
+        "sunday": "sun",
+    }
+
+    jour_key = jour.lower()
+    jour_key_adj = jour_adj.lower()
+
+    if jour_key not in day_map or jour_key_adj not in day_map:
+        print(f"❌ Jour non reconnu : {jour}/{jour_adj}", flush=True)
+        return
+
+    # Remove previous jobs for this schedule (optional, if you want to avoid duplicates)
+    try :  
+        apsched.remove_job(f"pub-{id_schedule}-{schedule_time_str}", jobstore=None)
+        apsched.remove_job(f"gen-{id_schedule}-{schedule_time_str}", jobstore=None)                 
+    except Exception as e:
+        print(f"❌ Erreur lors de la suppression des tâches : {e}", flush=True)
+
+    # Schedule publishing
+    apsched.add_job(
+        lambda: post_publishing_for_robot(id_social, user_id, id_schedule, ss),
+        CronTrigger(day_of_week=day_map[jour_key], hour=hour, minute=minute),
+        id=f"pub-{id_schedule}-{schedule_time_str}"
+    )
+
+    # Schedule generation
+    apsched.add_job(
+        lambda: post_generation_for_robot(user_id, id_social, id_schedule),
+        CronTrigger(day_of_week=day_map[jour_key_adj], hour=hour_adj, minute=minute_adj),
+        id=f"gen-{id_schedule}-{schedule_time_str}"
+    )
+
+    print(f"⏳ APScheduler: Tâche planifiée pour {id_social} ({user_id}) le {jour} à {hour:02d}:{minute:02d} et {jour_adj} à {hour_adj:02d}:{minute_adj:02d}", flush=True)
+
+
+
+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)}"
+                
+                # 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()
+            
+            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)
+        
+        print(f"✅ Scheduling added successfully", flush=True)
+        
+    except Exception as e:
+        print(f"❌ Error in add_scheduling: {e}", flush=True)
+
+    
+def planning():
+    df = db_manager.fetch_schedule_table()
+    if not df.empty :
+        replanifier_toutes_les_tâches(df)
+
+
+def post_publishing(state) :
+    
+    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"]
+    
+
+   
+    
+    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"
+        }
+    }
+
+    resp = requests.post(url, headers=headers, json=body)
+    print([resp.status_code, resp.text],flush = True)
+
+
+
+
+
+def post_generation(state) :
+    state.generated_post = client.predict(
+        code=state.user_inf.user.id,
+		api_name="/poster_linkedin"
+)
+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'
+    )
+        navigate(state, state.urlss)
+    
+   
+
+
+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])
+        
+    return " "
+    
+
+
+
+def add_source(state) :
+    
+    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)
+
+
+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)
+    
+    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_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)
+
+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)   
+
+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,state.user_inf = db_manager.authenticate_user(email, password)
+    
+    if success:
+        state.current_user = email
+        data = db_manager.fetch_source_table(state.user_inf.user.id) 
+        dataac = db_manager.fetch_account_table(state.user_inf.user.id)
+        state.data_schedule = db_manager.fetch_schedule_table_acc(state.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 = message
+
+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 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 = "Registration successful! Please log in."
+        state.show_register = False
+        # Clear form
+        state.register_email = ""
+        state.register_password = ""
+        state.confirm_password = ""
+    else:
+        state.message = message
+
+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 = ""
+

line_db.py

@@ -0,0 +1,209 @@
+import os
+from supabase import create_client, Client
+from pandas import json_normalize
+import pandas
+
+
+
+
+
+class DatabaseManager:
+    
+    def __init__(self,url,key):
+        # Supabase connection string format
+        # postgresql://postgres:[password]@[host]:[port]/[database]
+        self.supabase: Client = create_client(url, key)
+    
+    def create_user(self, email, password):
+        response = self.supabase.auth.sign_up(
+        {
+            "email": email,
+            "password": password,
+            }
+        
+            
+)
+        if response.user.aud == "authenticated" : # type: ignore
+            return True,"Un mail a été envoyé a votre address mail",response
+
+    def fetch_source_table(self,filter) :
+        response = (
+                self.supabase.table("Source")
+                .select("*")
+                .eq("user_id", filter)
+                .execute()
+            )
+        return response.data
+
+    def fetch_account_table(self,filter) :
+        response = (
+                self.supabase.table("Social_network")
+                .select("*")
+                .eq("id_utilisateur", filter)
+                .execute()
+            )
+        return response.data
+    
+    def fetch_schedule_table_acc(self,filter) :
+        response = (
+                self.supabase
+                .table("Scheduling")
+                .select("*, Social_network(id_utilisateur, social_network)")
+                .execute()
+            )
+        print(response.data,flush=True)
+        
+        df = json_normalize(response.data)
+        print(df,flush=True)
+        # Renomme les colonnes pour simplifier
+        if not df.empty  :
+            df.rename(columns={
+                "Social_network.id_utilisateur": "user_id",
+                "Social_network.social_network": "social_network"
+            }, inplace=True)
+
+            # Filtre les lignes pour l'utilisateur donné
+            df_user = df[df["user_id"] == filter].reset_index(drop=True)
+
+
+            return df_user
+        return None 
+
+    def delete_from_table(self,Source,values) :
+        response = (
+        self.supabase.table(Source)
+        .delete()
+        .in_("id", values)
+        .execute()
+    )
+    
+    
+        
+    def authenticate_user(self, email, password):
+        response = self.supabase.auth.sign_in_with_password(
+        {
+            "email": email,
+            "password": password,
+        }
+        
+)
+        if response.user.aud == "authenticated" and response.user.email_confirmed_at is not None : # type: ignore
+            return True,"Logged in  successfully",response
+        elif response.user.aud == "authenticated" : # type: ignore
+            return False,"Compte non confirmé",response
+        else :
+            return False,"Compte non existant",response
+
+    def add_token_network(self,token,social_network,account_name,uids,data):
+        response = (
+        self.supabase.table("Social_network")
+        .insert({"social_network": social_network,"account_name" :account_name, "id_utilisateur":uids,"token": token,
+                 "sub" : data["sub"],"given_name" : data["given_name"],"family_name" : data["family_name"],"picture" : data["picture"]  })
+        .execute()
+)   
+    def add_post(self,id_social,content,ids,tg : bool =False) :
+        response = (
+        self.supabase.table("Post_content")
+        .insert({"id_social": id_social,"Text_content" :content ,"is_published" : tg,"sched" : ids })
+        .execute())
+
+
+
+    def update_post(self,ids,idd):
+        response = (
+        self.supabase.table("Post_content")
+        .update({"is_published": True})
+        .eq("sched", idd)
+        .eq("id_social", ids)
+
+        .execute()
+    )
+
+    def fetching_post(self,uids,idd,active :bool = False) :
+        response = (
+        self.supabase.table("Post_content")
+        .select("*")
+        .eq("id_social", uids)
+        .eq("is_published", active)
+        .eq("sched", idd)
+
+                
+        .execute()
+)
+        data = response.data  # liste de dicts, chaque dict contient clé 'Social_network'
+        df = json_normalize(data)
+        return df
+
+
+    def fetching_user_identif(self,uids,rs) :
+        response = (
+        self.supabase.table("Social_network")
+        .select("*")
+        .eq("id_utilisateur", uids)
+        .eq("account_name", rs)
+                
+        .execute()
+)
+        return response
+
+   
+
+
+
+    def get_id_social(self,user_id: str, reseau: str):
+        
+        resp = (
+            self.supabase
+            .table("Social_network")
+            .select("id")
+            .eq("id_utilisateur", user_id)
+            .eq("account_name", reseau)
+            .execute()
+        )
+        
+        return resp.data[0]["id"]
+        
+
+    def create_scheduling_for_user(self,user_id: str, reseau: str, schedule_time: str,adj):
+        
+        id_social = self.get_id_social(user_id, reseau)
+        resp = (
+            self.supabase
+            .table("Scheduling")
+            .insert({
+                "id_social": id_social,
+                "schedule_time": schedule_time,
+                "adjusted_time": adj,
+                
+            })
+            .execute()
+        )
+        
+        print("Scheduling inséré avec succès.")
+        
+
+    def fetch_schedule_table(self) :
+        response = (
+            self.supabase
+                .table("Scheduling")
+                .select("*, Social_network(id_utilisateur, account_name)")
+                .execute()
+        )
+        
+        # 2️⃣ On normalise/la platifie la structure JSON en DataFrame
+        data = response.data  # liste de dicts, chaque dict contient clé 'Social_network'
+        df = json_normalize(data)
+        
+
+        df = df.rename(columns={"Social_network.id_utilisateur": "user_id"})
+        df = df.rename(columns={"Social_network.account_name": "social_network"})
+
+        
+        # 4️⃣ On peut réordonner ou filtrer les colonnes si besoin
+        # par exemple : id, id_social, user_id, schedule_time, created_at
+        cols = ["id", "id_social", "user_id", "schedule_time","social_network","adjusted_time","created_at"]
+        df = df[[c for c in cols if c in df.columns]]
+
+        return df
+
+

requirements.txt

@@ -0,0 +1,6 @@
+taipy
+psycopg2
+requests-oauthlib
+gradio
+supabase
+apscheduler

timing_lin.py

@@ -0,0 +1,67 @@
+import pandas as pd
+from datetime import datetime, timedelta
+import bisect
+
+JOUR_OFFSET = {
+    'Monday':    0, 'Tuesday':   1, 'Wednesday': 2, 'Thursday':  3,
+    'Friday':    4, 'Saturday':  5, 'Sunday':    6
+}
+BASE_DATE = datetime(2025, 1, 6)
+
+def parse_slot(slot_str):
+    jour, horaire = slot_str.split()
+    horaire = horaire.replace(';', ':')
+    h, m = map(int, horaire.split(':'))
+    date = BASE_DATE + timedelta(days=JOUR_OFFSET[jour])
+    return datetime(date.year, date.month, date.day, h, m)
+
+def format_slot(dt):
+    return f"{dt.strftime('%A')} {dt.strftime('%H:%M')}"
+
+
+def add_request(df_fixed, new_slot_str):
+    new_dt     = parse_slot(new_slot_str)
+    desired_dt = new_dt - timedelta(minutes=7)
+
+    # on récupère les adjusted existants triés
+    slots_dt = sorted(parse_slot(s) for s in df_fixed['adjusted_time'])
+
+    # on commence par placer final_dt = desired_dt, puis on recule au besoin
+    final_dt = desired_dt
+
+    # boucle tant que final_dt viole au moins une contrainte d'espacement
+    while True:
+        conflict = False
+
+        # 1) avec le schedule_time
+        if new_dt - final_dt < timedelta(minutes=10):
+            # on recule pour avoir exactement 7min d'avance
+            final_dt = new_dt - timedelta(minutes=10)
+            conflict = True
+
+        # 2) avec chaque adjusted existant
+        for slot in slots_dt:
+            if abs((slot - final_dt).total_seconds()) < 10*60:
+                # on recule de 7min par rapport à cet adjusted
+                # si slot > final, on repousse final à slot -7min
+                # sinon (slot < final), on recule encore de 7min
+                if slot > final_dt:
+                    final_dt = slot - timedelta(minutes=10)
+                else:
+                    final_dt = slot - timedelta(minutes=10)
+                conflict = True
+                break
+
+        if not conflict:
+            break  # on a trouvé un créneau valide
+
+    final_str = format_slot(final_dt)
+    df_fixed = pd.concat([
+        df_fixed,
+        pd.DataFrame([{
+            'schedule_time': new_slot_str,
+            'adjusted_time': final_str
+        }])
+    ], ignore_index=True)
+
+    return df_fixed.sort_values('adjusted_time').reset_index(drop=True),final_str