jj

.gitignore

@@ -177,4 +177,4 @@ docker-compose.override.yml
 .kilocode/
 docs/
 backend/tests/
-.qwen/
+.qwen/

Linkedin_poster_dev

@@ -1 +1 @@
-Subproject commit d8bd8606e9849085102cb06f066febfdc72f265c
+Subproject commit c2eff437aa77ba366d92bbe61164823d4736c7e8

backend/services/content_service.py

@@ -499,44 +499,43 @@ class ContentService:
                 user_rss_sources = rss_response.data if rss_response.data else []
                 
                 # Analyze each RSS source
-                for rss_source in user_rss_sources:
-                    rss_link = rss_source["source"]
+                
                     
-                    # Check if the source matches the keyword or if it's any source
-                    # We'll analyze any source that contains the keyword or is related to it
-                    if keyword.lower() in rss_link.lower():
-                        # Check if the source is a keyword rather than an RSS URL
-                        # If it's a keyword, generate a Google News RSS URL
-                        if self._is_url(rss_link):
-                            # It's a URL, use it directly
-                            feed_url = rss_link
-                        else:
-                            # It's a keyword, generate Google News RSS URL
-                            feed_url = self._generate_google_news_rss_from_string(rss_link)
-                        
-                        # Parse the RSS feed
-                        feed = feedparser.parse(feed_url)
-                        
-                        # Log some debug information
-                        current_app.logger.info(f"Processing RSS feed: {feed_url}")
-                        current_app.logger.info(f"Number of entries in feed: {len(feed.entries)}")
-                        
-                        # Extract ALL articles from the feed (without filtering by keyword again)
-                        for entry in feed.entries:
-                            # Use the same date handling as in the original ai_agent.py
-                            article_data = {
-                                'title': entry.title,
-                                'link': entry.link,
-                                'summary': entry.summary,
-                                'date': entry.get('published', entry.get('updated', None)),
-                                'content': entry.get('summary', '') + ' ' + entry.get('title', '')
-                            }
-                            
-                            # Log individual article data for debugging
-                            current_app.logger.info(f"Article title: {entry.title}")
-                            current_app.logger.info(f"Article date: {article_data['date']}")
-                            
-                            all_articles.append(article_data)
+                # Check if the source matches the keyword or if it's any source
+                # We'll analyze any source that contains the keyword or is related to it
+                
+                # Check if the source is a keyword rather than an RSS URL
+                # If it's a keyword, generate a Google News RSS URL
+                if self._is_url(keyword):
+                    # It's a URL, use it directly
+                    feed_url = keyword
+                else:
+                    # It's a keyword, generate Google News RSS URL
+                    feed_url = self._generate_google_news_rss_from_string(keyword)
+                
+                # Parse the RSS feed
+                feed = feedparser.parse(feed_url)
+                
+                # Log some debug information
+                current_app.logger.info(f"Processing RSS feed: {feed_url}")
+                current_app.logger.info(f"Number of entries in feed: {len(feed.entries)}")
+                
+                # Extract ALL articles from the feed (without filtering by keyword again)
+                for entry in feed.entries:
+                    # Use the same date handling as in the original ai_agent.py
+                    article_data = {
+                        'title': entry.title,
+                        'link': entry.link,
+                        'summary': entry.summary,
+                        'date': entry.get('published', entry.get('updated', None)),
+                        'content': entry.get('summary', '') + ' ' + entry.get('title', '')
+                    }
+                    
+                    # Log individual article data for debugging
+                    current_app.logger.info(f"Article title: {entry.title}")
+                    current_app.logger.info(f"Article date: {article_data['date']}")
+                    
+                    all_articles.append(article_data)
                 
                 # Create a DataFrame from the articles
                 df_articles = pd.DataFrame(all_articles)

docu_code/My_data_base_schema_.txt

@@ -2,49 +2,59 @@
 -- Table order and constraints may not be valid for execution.
 
 CREATE TABLE public.Post_content (
+  id bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
   id_social bigint,
   Text_content text,
+  image_content_url bytea,
   Video_content text,
   post_time time without time zone,
-  id bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
   created_at timestamp with time zone NOT NULL DEFAULT now(),
-  image_content_url bytea,
-  sched bigint,
   is_published boolean DEFAULT false,
+  sched bigint,
   CONSTRAINT Post_content_pkey PRIMARY KEY (id),
-  CONSTRAINT Post_content_id_social_fkey FOREIGN KEY (id_social) REFERENCES public.Social_network(id),
-  CONSTRAINT Post_content_sched_fkey FOREIGN KEY (sched) REFERENCES public.Scheduling(id)
+  CONSTRAINT Post_content_sched_fkey FOREIGN KEY (sched) REFERENCES public.Scheduling(id),
+  CONSTRAINT Post_content_id_social_fkey FOREIGN KEY (id_social) REFERENCES public.Social_network(id)
 );
 CREATE TABLE public.Scheduling (
   id bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
   id_social bigint,
-  created_at timestamp with time zone NOT NULL DEFAULT now(),
   schedule_time character varying,
+  created_at timestamp with time zone NOT NULL DEFAULT now(),
   adjusted_time character varying NOT NULL,
   CONSTRAINT Scheduling_pkey PRIMARY KEY (id),
   CONSTRAINT Scheduling_id_social_fkey FOREIGN KEY (id_social) REFERENCES public.Social_network(id)
 );
 CREATE TABLE public.Social_network (
-  id_utilisateur uuid DEFAULT gen_random_uuid(),
-  created_at timestamp with time zone NOT NULL DEFAULT now(),
+  id bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
   social_network character varying NOT NULL,
   token character varying NOT NULL UNIQUE,
+  id_utilisateur uuid DEFAULT gen_random_uuid(),
+  created_at timestamp with time zone NOT NULL DEFAULT now(),
   sub character varying NOT NULL UNIQUE,
   given_name character varying NOT NULL,
   picture character varying NOT NULL,
   family_name character varying NOT NULL,
-  id bigint GENERATED ALWAYS AS IDENTITY NOT NULL,
   account_name text NOT NULL UNIQUE,
+  expiration date,
   CONSTRAINT Social_network_pkey PRIMARY KEY (id),
   CONSTRAINT Social_network_id_utilisateur_fkey FOREIGN KEY (id_utilisateur) REFERENCES auth.users(id)
 );
 CREATE TABLE public.Source (
+  id bigint GENERATED ALWAYS AS IDENTITY NOT NULL UNIQUE,
   source text NOT NULL,
   categorie text,
   last_update timestamp without time zone DEFAULT now(),
   created_at timestamp with time zone NOT NULL DEFAULT now(),
   user_id uuid NOT NULL,
-  id bigint GENERATED ALWAYS AS IDENTITY NOT NULL UNIQUE,
   CONSTRAINT Source_pkey PRIMARY KEY (id, user_id),
   CONSTRAINT Source_user_id_fkey FOREIGN KEY (user_id) REFERENCES auth.users(id)
+);
+CREATE TABLE public.profiles (
+  id uuid NOT NULL,
+  email text UNIQUE,
+  raw_user_meta jsonb,
+  created_at timestamp with time zone DEFAULT now(),
+  updated_at timestamp with time zone,
+  CONSTRAINT profiles_pkey PRIMARY KEY (id),
+  CONSTRAINT profiles_id_fkey FOREIGN KEY (id) REFERENCES auth.users(id)
 );

sprint_change_proposal.md

@@ -0,0 +1,87 @@
+# Sprint Change Proposal: LinkedIn Token Expiration Management System
+
+## Analysis Summary
+
+**Original Issue**: LinkedIn tokens expire after 2 months, requiring manual reconnection process that creates a poor user experience.
+
+**Impact Analysis**: 
+- Currently, the `Social_network` table already has an `expiration` column that can be leveraged
+- No schema changes needed, only implementation of business logic
+- Requires background task scheduling and email notification system
+- Affects user experience for LinkedIn integration users
+
+**Rationale for Chosen Path**: Implementing automated token refresh with 50-day cycle and daily background checks minimizes user disruption while maintaining security best practices.
+
+## Specific Proposed Edits
+
+### 1. Update Account Linking Process
+
+**Current**: LinkedIn tokens are stored without expiration tracking
+
+**Proposed Changes**:
+- Modify the LinkedIn account linking process to automatically set the `expiration` column to 50 days after link date
+- Add validation to ensure the `expiration` column is properly set during the connection process
+
+### 2. Create Background Task Scheduler
+
+**Current**: No automated expiration checks exist
+
+**Proposed Changes**:
+- Implement a background task that runs at noon and midnight daily
+- Create a function to check for accounts with expiration date equal to current date
+- Add token refresh logic for LinkedIn tokens
+- Implement error handling and logging
+
+### 3. Implement Token Refresh Process
+
+**Current**: No automated refresh mechanism exists
+
+**Proposed Changes**:
+- Create function to perform LinkedIn token refresh using LinkedIn's API
+- Handle successful refresh (update tokens and expiration)
+- Handle failed refresh (send user notification)
+
+### 4. Implement Email Notification System
+
+**Current**: No automated notification system exists for failed refreshes
+
+**Proposed Changes**:
+- Create function to send email notification when refresh fails
+- Include clear instructions for users to reconnect their LinkedIn account
+
+### 5. Add Refresh Token Storage
+
+**Current**: Only access token is stored in the `token` column
+
+**Proposed Changes**:
+- Modify the initial LinkedIn connection flow to also store the refresh token
+- Update schema to add refresh_token column or modify existing storage approach
+
+## Additional Implementation Considerations
+
+### 6. Logging and Monitoring
+- Add comprehensive logging for the refresh process
+- Create monitoring for failed refresh attempts
+- Log successful refreshes for tracking
+
+### 7. Error Handling Improvements
+- Implement retry logic for temporary failures
+- Handle rate limiting from LinkedIn API
+- Graceful degradation when refresh fails
+
+### 8. Testing Requirements
+- Unit tests for the refresh logic
+- Integration tests for the scheduling system
+- Testing of email notification system
+
+## Success Metrics
+- Reduction in manual reconnection requests
+- Improved user retention for LinkedIn integration
+- Decreased support tickets related to token expiration
+
+## Implementation Timeline
+1. **Day 1**: Implement token refresh logic and database updates
+2. **Day 2**: Implement background scheduler and email notifications
+3. **Week 1-2**: Testing, monitoring, and adjustments
+
+This proposal addresses the LinkedIn token expiration issue while leveraging your existing database structure efficiently. The system will automatically handle token refresh for users, sending notifications only when automatic refresh fails, thus improving the user experience significantly.