fff

.env.hf

@@ -0,0 +1,9 @@
+# Hugging Face Spaces environment variables
+# This file is for reference only. Set actual values in Hugging Face Spaces secrets.
+
+# Celery configuration for Redis
+CELERY_BROKER_URL=redis://localhost:6379/0
+CELERY_RESULT_BACKEND=redis://localhost:6379/0
+
+# Port for Hugging Face Spaces
+PORT=7860

.gitignore

@@ -0,0 +1,168 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat.pid
+# Do NOT ignore celerybeat-schedule - we want to commit this for persistence when possible
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Node.js dependencies
+node_modules/
+
+# Vite build output
+frontend/dist/
+frontend/build/
+
+# Local environment files
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# VS Code
+.vscode/
+
+# IDE files
+.idea/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+
+# Temp files
+*.tmp
+*.temp
+
+# Supabase
+supabase/.temp/
+
+# Docker
+docker-compose.override.yml

Dockerfile

@@ -0,0 +1,31 @@
+FROM python:3.10
+
+WORKDIR /app
+
+# Install Node.js for frontend build
+RUN curl -fsSL https://deb.nodesource.com/setup_16.x | bash -
+RUN apt-get update && apt-get install -y nodejs
+
+# Copy and install Python dependencies
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+# Copy package files for frontend
+COPY frontend/package*.json ./frontend/
+# Install frontend dependencies
+RUN cd frontend && npm install
+
+# Copy all files
+COPY . .
+
+# Build frontend
+RUN cd frontend && npm run build
+
+# Make the startup script executable
+RUN chmod +x start_app.py
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "start_app.py"]

FINAL_DOCUMENTATION.md

@@ -0,0 +1,692 @@
+# Lin React Clone - Final Documentation
+
+## Project Overview
+
+This documentation provides a comprehensive overview of the Lin React Clone project, which is a modern reimplementation of the original Taipy-based Lin application using a React frontend with a Flask API backend. The project maintains all core functionality while improving the architecture for better maintainability and scalability.
+
+## Table of Contents
+
+1. [Architecture Overview](#architecture-overview)
+2. [Backend Implementation](#backend-implementation)
+3. [Frontend Implementation](#frontend-implementation)
+4. [API Documentation](#api-documentation)
+5. [Deployment Guide](#deployment-guide)
+6. [Testing Strategy](#testing-strategy)
+7. [Future Enhancements](#future-enhancements)
+
+## Architecture Overview
+
+### System Components
+
+The Lin React Clone consists of two main components:
+
+1. **Frontend (React)**
+   - User interface built with React
+   - State management with Redux Toolkit
+   - Responsive design for all device sizes
+   - Component-based architecture
+
+2. **Backend (Flask API)**
+   - RESTful API built with Flask
+   - Database integration with Supabase
+   - Task scheduling with APScheduler
+   - External API integrations (LinkedIn, Hugging Face)
+
+### Data Flow
+
+```
+[React Frontend] ↔ [Flask API] ↔ [Supabase Database]
+                        ↓
+              [External APIs: LinkedIn, Hugging Face]
+                        ↓
+                  [APScheduler Tasks]
+```
+
+### Technology Stack
+
+#### Backend
+- Flask (Python web framework)
+- Supabase (Database and authentication)
+- APScheduler (Task scheduling)
+- requests (HTTP library)
+- requests-oauthlib (OAuth support)
+- gradio-client (Hugging Face API)
+- Flask-JWT-Extended (JWT token management)
+
+#### Frontend
+- React (JavaScript library)
+- Redux Toolkit (State management)
+- React Router (Routing)
+- Axios (HTTP client)
+- Material-UI (UI components)
+
+## Backend Implementation
+
+### Project Structure
+
+```
+backend/
+├── app.py                 # Flask application entry point
+├── config.py              # Configuration settings
+├── requirements.txt       # Python dependencies
+├── .env.example          # Environment variables example
+├── models/                # Data models
+│   ├── user.py            # User model
+│   ├── social_account.py  # Social media account model
+│   ├── source.py          # RSS source model
+│   ├── post.py            # Post content model
+│   └── schedule.py        # Scheduling model
+├── api/                   # API endpoints
+│   ├── auth.py            # Authentication endpoints
+│   ├── sources.py         # Source management endpoints
+│   ├── accounts.py        # Social account endpoints
+│   ├── posts.py           # Post management endpoints
+│   └── schedules.py       # Scheduling endpoints
+├── services/              # Business logic
+│   ├── auth_service.py    # Authentication service
+│   ├── linkedin_service.py# LinkedIn integration service
+│   ├── content_service.py # Content generation service
+│   └── schedule_service.py# Scheduling service
+├── utils/                 # Utility functions
+│   └── database.py        # Database connection
+└── scheduler/             # Task scheduling
+    └── task_scheduler.py  # Scheduling implementation
+```
+
+### Key Features
+
+#### Authentication System
+- JWT-based authentication with secure token management
+- User registration with email confirmation
+- User login/logout functionality
+- Password hashing with bcrypt
+- Supabase Auth integration
+
+#### Source Management
+- CRUD operations for RSS sources
+- Integration with Supabase database
+- Validation and error handling
+
+#### Social Account Management
+- LinkedIn OAuth2 integration
+- Account linking and token storage
+- Profile information retrieval
+
+#### Post Management
+- AI-powered content generation using Hugging Face API
+- Post creation and storage
+- LinkedIn publishing integration
+- Image handling for posts
+
+#### Scheduling System
+- APScheduler for task management
+- Recurring schedule creation
+- Automatic content generation and publishing
+- Conflict resolution for overlapping schedules
+
+## Frontend Implementation
+
+### Project Structure
+
+```
+frontend/
+├── src/
+│   ├── components/        # Reusable components
+│   │   ├── Header/        # Application header
+│   │   └── Sidebar/       # Navigation sidebar
+│   ├── pages/             # Page components
+│   │   ├── Login.js       # Login page
+│   │   ├── Register.js    # Registration page
+│   │   ├── Dashboard.js   # Dashboard page
+│   │   ├── Sources.js     # Source management page
+│   │   ├── Posts.js       # Post management page
+│   │   └── Schedule.js    # Scheduling page
+│   ├── services/          # API service layer
+│   │   ├── api.js         # Axios instance and interceptors
+│   │   ├── authService.js # Authentication API calls
+│   │   ├── sourceService.js# Source management API calls
+│   │   ├── accountService.js# Account management API calls
+│   │   ├── postService.js # Post management API calls
+│   │   └── scheduleService.js# Scheduling API calls
+│   ├── store/             # Redux store
+│   │   ├── index.js       # Store configuration
+│   │   └── reducers/      # Redux reducers and actions
+│   ├── App.js             # Main application component
+│   ├── App.css            # Global application styles
+│   ├── index.js           # Application entry point
+│   └── index.css          # Global CSS styles
+├── public/                # Static assets
+└── package.json           # Project dependencies and scripts
+```
+
+### Key Features
+
+#### Authentication System
+- Login and registration forms
+- JWT token management in localStorage
+- Protected routes
+- User session management
+
+#### Dashboard
+- Overview statistics
+- Recent activity display
+- Quick action buttons
+
+#### Source Management
+- Add/delete RSS sources
+- List view of all sources
+- Form validation
+
+#### Post Management
+- AI content generation interface
+- Post creation form
+- Draft and published post management
+- Publish and delete functionality
+
+#### Scheduling
+- Schedule creation form with time selection
+- Day selection interface
+- List view of all schedules
+- Delete functionality
+
+## API Documentation
+
+### Authentication Endpoints
+
+#### POST /api/auth/register
+Register a new user
+
+**Request Body:**
+```json
+{
+  "email": "string",
+  "password": "string",
+  "confirm_password": "string"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "User registered successfully",
+  "user": {
+    "id": "string",
+    "email": "string",
+    "created_at": "datetime"
+  }
+}
+```
+
+#### POST /api/auth/login
+Login user
+
+**Request Body:**
+```json
+{
+  "email": "string",
+  "password": "string"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "token": "string",
+  "user": {
+    "id": "string",
+    "email": "string"
+  }
+}
+```
+
+#### POST /api/auth/logout
+Logout user
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Logged out successfully"
+}
+```
+
+#### GET /api/auth/user
+Get current user
+
+**Response:**
+```json
+{
+  "success": true,
+  "user": {
+    "id": "string",
+    "email": "string"
+  }
+}
+```
+
+### Source Endpoints
+
+#### GET /api/sources
+Get all sources for current user
+
+**Response:**
+```json
+{
+  "success": true,
+  "sources": [
+    {
+      "id": "string",
+      "user_id": "string",
+      "source": "string",
+      "category": "string",
+      "last_update": "datetime",
+      "created_at": "datetime"
+    }
+  ]
+}
+```
+
+#### POST /api/sources
+Add a new source
+
+**Request Body:**
+```json
+{
+  "source": "string"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "source": {
+    "id": "string",
+    "user_id": "string",
+    "source": "string",
+    "category": "string",
+    "last_update": "datetime",
+    "created_at": "datetime"
+  }
+}
+```
+
+#### DELETE /api/sources/{id}
+Delete a source
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Source deleted successfully"
+}
+```
+
+### Account Endpoints
+
+#### GET /api/accounts
+Get all social accounts for current user
+
+**Response:**
+```json
+{
+  "success": true,
+  "accounts": [
+    {
+      "id": "string",
+      "user_id": "string",
+      "social_network": "string",
+      "account_name": "string",
+      "created_at": "datetime"
+    }
+  ]
+}
+```
+
+#### POST /api/accounts
+Add a new social account
+
+**Request Body:**
+```json
+{
+  "account_name": "string",
+  "social_network": "string"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "account": {
+    "id": "string",
+    "user_id": "string",
+    "social_network": "string",
+    "account_name": "string",
+    "created_at": "datetime"
+  }
+}
+```
+
+#### DELETE /api/accounts/{id}
+Delete a social account
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Account deleted successfully"
+}
+```
+
+### Post Endpoints
+
+#### GET /api/posts
+Get all posts for current user
+
+**Query Parameters:**
+- `published` (boolean): Filter by published status
+
+**Response:**
+```json
+{
+  "success": true,
+  "posts": [
+    {
+      "id": "string",
+      "social_account_id": "string",
+      "text_content": "string",
+      "is_published": "boolean",
+      "sched": "string",
+      "image_content_url": "string",
+      "created_at": "datetime",
+      "scheduled_at": "datetime"
+    }
+  ]
+}
+```
+
+#### POST /api/posts/generate
+Generate AI content
+
+**Response:**
+```json
+{
+  "success": true,
+  "content": "string"
+}
+```
+
+#### POST /api/posts
+Create a new post
+
+**Request Body:**
+```json
+{
+  "social_account_id": "string",
+  "text_content": "string",
+  "image_content_url": "string",
+  "scheduled_at": "datetime"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "post": {
+    "id": "string",
+    "social_account_id": "string",
+    "text_content": "string",
+    "is_published": "boolean",
+    "sched": "string",
+    "image_content_url": "string",
+    "created_at": "datetime",
+    "scheduled_at": "datetime"
+  }
+}
+```
+
+#### POST /api/posts/{id}/publish
+Publish a post
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Post published successfully"
+}
+```
+
+#### DELETE /api/posts/{id}
+Delete a post
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Post deleted successfully"
+}
+```
+
+### Schedule Endpoints
+
+#### GET /api/schedules
+Get all schedules for current user
+
+**Response:**
+```json
+{
+  "success": true,
+  "schedules": [
+    {
+      "id": "string",
+      "social_account_id": "string",
+      "schedule_time": "string",
+      "adjusted_time": "string",
+      "created_at": "datetime"
+    }
+  ]
+}
+```
+
+#### POST /api/schedules
+Create a new schedule
+
+**Request Body:**
+```json
+{
+  "social_network": "string",
+  "schedule_time": "string",
+  "days": ["string"]
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "schedules": [
+    {
+      "id": "string",
+      "social_account_id": "string",
+      "schedule_time": "string",
+      "adjusted_time": "string",
+      "created_at": "datetime"
+    }
+  ]
+}
+```
+
+#### DELETE /api/schedules/{id}
+Delete a schedule
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Schedule deleted successfully"
+}
+```
+
+## Deployment Guide
+
+### Backend Deployment
+
+1. **Environment Setup**
+   ```bash
+   # Copy environment example
+   cp .env.example .env
+   
+   # Edit .env with your values
+   ```
+
+2. **Install Dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Run Application**
+   ```bash
+   python app.py
+   ```
+
+4. **Docker Deployment**
+   ```bash
+   docker build -t lin-backend .
+   docker run -p 5000:5000 lin-backend
+   ```
+
+### Frontend Deployment
+
+1. **Install Dependencies**
+   ```bash
+   npm install
+   ```
+
+2. **Build for Production**
+   ```bash
+   npm run build
+   ```
+
+3. **Serve Build**
+   ```bash
+   npm install -g serve
+   serve -s build
+   ```
+
+### Environment Variables
+
+#### Backend (.env)
+```
+SUPABASE_URL=your_supabase_project_url
+SUPABASE_KEY=your_supabase_api_key
+CLIENT_ID=your_linkedin_client_id
+CLIENT_SECRET=your_linkedin_client_secret
+REDIRECT_URL=your_redirect_url
+HUGGING_KEY=your_hugging_face_api_key
+JWT_SECRET_KEY=your_jwt_secret_key
+SECRET_KEY=your_secret_key
+DEBUG=True
+SCHEDULER_ENABLED=True
+PORT=5000
+```
+
+#### Frontend (.env)
+```
+REACT_APP_API_URL=http://localhost:5000/api
+```
+
+## Testing Strategy
+
+### Backend Testing
+
+1. **Unit Tests**
+   - Model validation tests
+   - Service layer tests
+   - Utility function tests
+
+2. **Integration Tests**
+   - API endpoint tests
+   - Database integration tests
+   - External API integration tests
+
+3. **Test Commands**
+   ```bash
+   # Run all tests
+   pytest
+   
+   # Run tests with coverage
+   pytest --cov=.
+   ```
+
+### Frontend Testing
+
+1. **Component Tests**
+   - Rendering tests
+   - User interaction tests
+   - State management tests
+
+2. **Integration Tests**
+   - Form submission tests
+   - API integration tests
+   - Routing tests
+
+3. **Test Commands**
+   ```bash
+   # Run all tests
+   npm test
+   
+   # Run tests in watch mode
+   npm test -- --watch
+   ```
+
+## Future Enhancements
+
+### Backend Enhancements
+1. **Advanced Analytics**
+   - Post performance tracking
+   - User engagement metrics
+   - Content effectiveness analysis
+
+2. **Multi-Platform Support**
+   - Twitter integration
+   - Facebook integration
+   - Instagram integration
+
+3. **Enhanced Scheduling**
+   - Advanced scheduling algorithms
+   - Timezone support
+   - Recurrence patterns
+
+4. **Performance Improvements**
+   - Caching strategies
+   - Database optimization
+   - Asynchronous processing
+
+### Frontend Enhancements
+1. **Advanced UI Components**
+   - Data visualization dashboards
+   - Real-time updates
+   - Drag-and-drop scheduling
+
+2. **Enhanced User Experience**
+   - Dark mode support
+   - Keyboard shortcuts
+   - Accessibility improvements
+
+3. **Mobile Enhancements**
+   - Progressive Web App (PWA) support
+   - Native mobile features
+   - Offline capabilities
+
+4. **Advanced Features**
+   - Content calendar view
+   - Team collaboration features
+   - Content approval workflows
+
+## Conclusion
+
+The Lin React Clone project successfully reimplements the original Taipy-based application with a modern, scalable architecture. The separation of concerns between the frontend and backend allows for independent development and deployment, while the RESTful API design ensures clear communication between components. The implementation includes all core features of the original application while providing a foundation for future enhancements and improvements.

GEMINI.md

@@ -0,0 +1,160 @@
+# Lin - Community Manager Assistant for LinkedIn
+
+## Project Overview
+
+Lin is a comprehensive community management tool designed to help users automate and streamline their LinkedIn activities. The project follows a modern full-stack architecture with:
+
+- **Frontend**: React application with Vite build system, utilizing Tailwind CSS for styling and Redux for state management
+- **Backend**: Flask-based REST API with SQLAlchemy for database operations and Supabase for authentication
+- **Key Features**: LinkedIn OAuth integration, content scheduling, post management, and analytics
+
+## Project Structure
+
+```
+Lin/
+├── package.json              # Root package.json with combined scripts
+├── frontend/                 # React frontend application
+│   ├── package.json          # Frontend-specific dependencies
+│   ├── src/                  # React source code
+│   ├── public/               # Static assets
+│   └── build/                # Build output
+├── backend/                  # Flask backend API
+│   ├── app.py                # Main application file
+│   ├── requirements.txt      # Python dependencies
+│   ├── api/                  # API endpoints
+│   ├── models/               # Data models
+│   ├── services/             # Business logic
+│   └── utils/                # Utility functions
+└── README.md                 # Project documentation
+```
+
+## Building and Running
+
+### Prerequisites
+
+- Node.js (v16 or higher)
+- Python (v3.8 or higher)
+- npm (v8 or higher)
+
+### Installation
+
+**Option 1: Using the root package.json (Recommended)**
+
+```bash
+# Install all dependencies
+npm install
+
+# Setup the project
+npm run setup
+
+# Start both frontend and backend
+npm start
+```
+
+**Option 2: Manual installation**
+
+```bash
+# Install frontend dependencies
+cd frontend
+npm install
+
+# Install backend dependencies
+cd ../backend
+pip install -r requirements.txt
+```
+
+### Development Servers
+
+- `npm run dev:frontend` - Start frontend development server
+- `npm run dev:backend` - Start backend development server
+- `npm run dev:all` - Start both servers concurrently
+- `npm start` - Alias for `npm run dev:all`
+
+### Build & Test
+
+- `npm run build` - Build frontend for production
+- `npm run preview` - Preview production build
+- `npm run test` - Run frontend tests
+- `npm run test:backend` - Run backend tests
+- `npm run lint` - Run ESLint
+- `npm run lint:fix` - Fix ESLint issues
+
+## Development Conventions
+
+### Frontend
+
+- Built with React and Vite
+- Uses Tailwind CSS for styling
+- Implements Redux for state management
+- Follows responsive design principles with mobile-first approach
+- Uses React Router for navigation
+- Implements proper error boundaries and loading states
+
+### Backend
+
+- Built with Flask
+- Uses Supabase for authentication and database
+- Implements JWT for token-based authentication
+- Uses SQLAlchemy for database operations
+- Follows REST API design principles
+
+### UI Components
+
+The application features several key UI components:
+
+1. **Header**: Contains the application logo and user profile/logout functionality
+2. **Sidebar**: Navigation menu with links to different sections of the app
+3. **Responsive Design**: Adapts to different screen sizes with special handling for mobile devices
+
+### Key Features
+
+1. **Authentication**: Login and registration functionality with JWT tokens
+2. **LinkedIn Integration**: OAuth integration for connecting LinkedIn accounts
+3. **Content Management**: Create, edit, and schedule posts
+4. **Analytics**: Dashboard with overview and analytics
+5. **Responsive UI**: Mobile-friendly design with optimized touch interactions
+
+## Environment Setup
+
+### Frontend Environment
+
+```bash
+# Copy environment file
+cd frontend
+cp .env.example .env.local
+
+# Edit environment variables
+# Open .env.local and add your required values
+```
+
+**Required Frontend Variables**:
+- `REACT_APP_API_URL` - Backend API URL (default: http://localhost:5000)
+
+### Backend Environment
+
+```bash
+# Copy environment file
+cd backend
+cp .env.example .env
+
+# Edit environment variables
+# Open .env and add your required values
+```
+
+**Required Backend Variables**:
+- `SUPABASE_URL` - Your Supabase project URL
+- `SUPABASE_KEY` - Your Supabase API key
+- `CLIENT_ID` - LinkedIn OAuth client ID
+- `CLIENT_SECRET` - LinkedIn OAuth client secret
+- `REDIRECT_URL` - LinkedIn OAuth redirect URL
+- `HUGGING_KEY` - Hugging Face API key
+- `JWT_SECRET_KEY` - Secret key for JWT token generation
+- `SECRET_KEY` - Flask secret key
+- `DEBUG` - Debug mode (True/False)
+- `SCHEDULER_ENABLED` - Enable/disable task scheduler (True/False)
+- `PORT` - Port to run the application on (default: 5000)
+
+## Development URLs
+
+- **Frontend**: http://localhost:3000
+- **Backend API**: http://localhost:5000

HEADER_CSS_ANALYSIS.md

@@ -0,0 +1,128 @@
+# Header Component CSS Analysis Report
+
+## Overview
+
+This report analyzes the Header component in the Lin application to identify potential alignment, spacing, and layout issues based on the current implementation and CSS styles.
+
+## Current Header Structure
+
+The Header component uses a flex layout with three main sections:
+1. Logo and App Title (left)
+2. Desktop Navigation (center) - Currently empty
+3. User Profile and Logout (right)
+
+## Identified Issues
+
+### 1. Height Inconsistency
+**Issue**: The Header component has a fixed height that changes between screen sizes (h-14 on mobile, h-16 on larger screens), but the CSS in header.css defines a fixed height of 4rem (64px).
+
+**Files Affected**:
+- `frontend/src/components/Header/Header.jsx` (line 47)
+- `frontend/src/css/components/header.css` (line 10)
+
+**Impact**: This inconsistency can cause layout shifts and alignment issues between different screen sizes.
+
+### 2. Vertical Alignment Issues
+**Issue**: The flex container uses `items-center` for vertical alignment, but the varying heights between mobile (h-14 = 56px) and desktop (h-16 = 64px) can cause elements to appear misaligned.
+
+**Files Affected**:
+- `frontend/src/components/Header/Header.jsx` (line 47)
+
+### 3. Spacing Inconsistencies
+**Issue**: The Header uses different spacing values for mobile and desktop:
+- Logo section: `space-x-2` on mobile, `space-x-3` on larger screens
+- User profile section: `space-x-3` on mobile, `space-x-4` on larger screens
+
+**Files Affected**:
+- `frontend/src/components/Header/Header.jsx` (lines 50, 73, 82)
+
+### 4. Responsive Breakpoint Mismatch
+**Issue**: The Header component uses Tailwind's `lg:` prefix for desktop elements, but the CSS media queries in header.css use `max-width: 767px`. This creates a mismatch where elements might not display correctly at the 1024px breakpoint.
+
+**Files Affected**:
+- `frontend/src/components/Header/Header.jsx` (multiple lines)
+- `frontend/src/css/components/header.css` (line 73)
+
+### 5. Z-Index Conflicts
+**Issue**: The Header uses `z-50` in Tailwind classes, but the CSS defines a z-index of `var(--z-40)`. Additionally, the Sidebar has `z-index: var(--z-50)` in CSS, which could cause layering issues.
+
+**Files Affected**:
+- `frontend/src/components/Header/Header.jsx` (line 44)
+- `frontend/src/css/components/header.css` (line 13)
+- `frontend/src/css/components/sidebar.css` (line 13)
+
+### 6. Padding Inconsistencies
+**Issue**: The header-content div uses responsive padding (`px-3 sm:px-4 lg:px-8`) but the CSS in header.css doesn't account for these variations.
+
+**Files Affected**:
+- `frontend/src/components/Header/Header.jsx` (line 45)
+- `frontend/src/css/components/header.css` (line 19)
+
+### 7. Mobile Menu Button Alignment
+**Issue**: The mobile menu button section uses `space-x-2` for spacing, but the user avatar and button have different styling between authenticated and unauthenticated states.
+
+**Files Affected**:
+- `frontend/src/components/Header/Header.jsx` (lines 111, 125)
+
+## Recommendations
+
+### 1. Standardize Height
+**Solution**: Use a consistent height across all screen sizes or adjust the CSS to match the Tailwind classes.
+
+```jsx
+// In Header.jsx, consider using consistent height:
+<div className="flex items-center justify-between h-16">
+```
+
+### 2. Improve Vertical Alignment
+**Solution**: Ensure all elements within the Header have consistent vertical alignment by using the same height and alignment properties.
+
+### 3. Standardize Spacing
+**Solution**: Use consistent spacing values or create CSS variables for the different spacing to maintain consistency.
+
+### 4. Align Responsive Breakpoints
+**Solution**: Ensure Tailwind breakpoints and CSS media queries use the same values. Consider using Tailwind's default breakpoints or customizing them to match.
+
+### 5. Resolve Z-Index Conflicts
+**Solution**: Standardize z-index values across components. The Header should have a lower z-index than the Sidebar when the Sidebar is active.
+
+### 6. Harmonize Padding
+**Solution**: Either rely solely on Tailwind classes for padding or ensure CSS values match the Tailwind spacing.
+
+### 7. Consistent Mobile Menu
+**Solution**: Standardize the mobile menu button styling regardless of authentication state to ensure consistent appearance.
+
+## CSS Specificity Issues
+
+### 1. Overriding Styles
+The Header component uses inline Tailwind classes that may override the styles defined in header.css due to CSS specificity rules.
+
+### 2. Missing Responsive Styles
+Some responsive behaviors are implemented with Tailwind classes but not reflected in the CSS files, which could cause maintenance issues.
+
+## Accessibility Considerations
+
+### 1. Focus Management
+The Header includes proper ARIA attributes and focus management, which is good for accessibility.
+
+### 2. Keyboard Navigation
+The component supports keyboard navigation with proper event handlers.
+
+## Performance Considerations
+
+### 1. CSS File Structure
+The separation of CSS into modular files is good for maintainability, but ensure there are no conflicting styles between Tailwind classes and custom CSS.
+
+### 2. Animation Performance
+The Header includes animations (animate-fade-down), which should be optimized for performance, especially on mobile devices.
+
+## Conclusion
+
+The Header component has several alignment and spacing issues primarily due to:
+
+1. Inconsistent height definitions between Tailwind classes and CSS
+2. Mismatched responsive breakpoints between Tailwind and CSS media queries
+3. Z-index conflicts between Header and Sidebar components
+4. Inconsistent spacing values across different screen sizes
+
+Addressing these issues will improve the visual consistency and user experience of the Header component across different devices and screen sizes.

HEADER_FIX_SUMMARY.md

@@ -0,0 +1,68 @@
+# Header Component Fix Summary
+
+## Issues Identified and Fixed
+
+### 1. Height Consistency
+**Issue**: Inconsistent height definitions between Tailwind classes (`h-14` on mobile, `h-16` on larger screens) and CSS (`height: 4rem`).
+
+**Fix**: Standardized to `h-16` (4rem/64px) across all screen sizes for both Tailwind classes and CSS.
+
+### 2. Padding Consistency
+**Issue**: Header content padding was defined with Tailwind classes (`px-3 sm:px-4 lg:px-8`) but not reflected in CSS.
+
+**Fix**: Updated CSS to match the corrected Tailwind classes:
+- Mobile: 1rem (px-4)
+- Small screens (sm): 1.5rem (px-6)
+- Large screens (lg): 2rem (px-8)
+
+### 3. Responsive Breakpoint Alignment
+**Issue**: Mismatch between Tailwind's `lg:` breakpoint (1024px) and CSS media query (767px).
+
+**Fix**: Updated CSS media queries to use 1023px max-width to match Tailwind's lg breakpoint.
+
+### 4. Z-Index Standardization
+**Issue**: Header was using `z-50` which could conflict with the Sidebar's z-index.
+
+**Fix**: 
+- Header: z-index 40 (var(--z-40))
+- Sidebar: z-index 50 (var(--z-50)) on mobile to ensure it appears above the header
+
+### 5. Spacing Standardization
+**Issue**: Inconsistent spacing between elements on different screen sizes.
+
+**Fix**: Standardized spacing values:
+- Logo section: `space-x-3` (consistent across screen sizes)
+- User profile section: `space-x-4` (consistent across screen sizes)
+
+### 6. Component Structure Improvements
+**Issue**: Minor inconsistencies in component structure.
+
+**Fix**:
+- Standardized button sizes and padding
+- Consistent avatar sizes
+- Unified text sizes and styling
+- Improved mobile menu button sizing
+
+## Files Updated
+
+1. **Header.jsx** - Component with standardized heights, spacing, and responsive behavior
+2. **header.css** - CSS file with aligned breakpoints, consistent padding, and proper z-index management
+
+## Benefits of Fixes
+
+1. **Visual Consistency**: Header will appear consistent across all screen sizes
+2. **Improved Responsiveness**: Proper breakpoint alignment ensures correct behavior
+3. **Better Layering**: Correct z-index relationships between Header and Sidebar
+4. **Accessibility**: Maintained all existing accessibility features
+5. **Performance**: Optimized CSS for better rendering performance
+6. **Maintainability**: Aligned Tailwind and CSS implementations for easier maintenance
+
+## Testing Recommendations
+
+1. **Cross-Browser Testing**: Verify appearance in Chrome, Firefox, Safari, and Edge
+2. **Responsive Testing**: Check behavior at various screen sizes (mobile, tablet, desktop)
+3. **Z-Index Testing**: Ensure proper layering of Header and Sidebar components
+4. **Accessibility Testing**: Verify keyboard navigation and screen reader compatibility
+5. **Performance Testing**: Confirm smooth animations and transitions
+
+These fixes address all the alignment, spacing, and layout issues identified in the Header component while maintaining all existing functionality and accessibility features.

HUGGING_FACE_DEPLOYMENT.md

@@ -0,0 +1,197 @@
+# Hosting Lin on Hugging Face Spaces
+
+This guide explains how to deploy your Lin application (Vite + React + Tailwind frontend with Flask backend) on Hugging Face Spaces.
+
+## Project Structure
+
+Hugging Face Spaces requires both frontend and backend to run in the same environment. Organize your project as follows:
+
+```
+Lin/
+├── backend/
+│   ├── app.py
+│   ├── requirements.txt
+│   └── ... (other backend files)
+├── frontend/
+│   ├── package.json
+│   ├── vite.config.js
+│   └── ... (other frontend files)
+├── app.py              # Main entry point for Flask
+├── requirements.txt    # Python dependencies
+├── runtime.txt         # Python version (optional)
+├── README.md           # Project documentation
+└── Dockerfile          # Docker configuration (optional)
+```
+
+## Prerequisites
+
+1. Build your Vite frontend (Hugging Face Spaces cannot run Vite dev server)
+2. Configure Flask to serve both API endpoints and static frontend files
+3. Set up proper environment variables for production
+
+## Step-by-Step Deployment
+
+### 1. Build the Frontend
+
+Before deployment, you need to build your React frontend:
+
+```bash
+cd frontend
+npm install
+npm run build
+```
+
+This creates a `dist/` folder with static assets that Flask can serve.
+
+### 2. Configure Flask to Serve Frontend
+
+Your Flask app is already configured to serve the frontend. The `backend/app.py` file includes routes to serve static files from the `frontend/dist` directory.
+
+### 3. Update Environment Variables
+
+Update your `.env` files for production:
+
+**frontend/.env.production:**
+```bash
+VITE_API_URL=https://zelyanoth-lin.hf.space
+VITE_NODE_ENV=production
+```
+
+**backend/.env:**
+```bash
+# LinkedIn OAuth configuration
+REDIRECT_URL=https://zelyanoth-lin.hf.space/auth/callback
+
+# Other configurations...
+```
+
+Don't forget to update your LinkedIn App settings in the LinkedIn Developer Console to use this redirect URL.
+
+### 4. Root requirements.txt
+
+Create a `requirements.txt` file at the project root with all necessary Python dependencies:
+
+```
+flask
+flask-jwt-extended
+supabase
+python-dotenv
+celery
+redis
+# Add other backend dependencies
+```
+
+### 5. Runtime Configuration (Optional)
+
+Create a `runtime.txt` file to specify the Python version:
+
+```
+python-3.10
+```
+
+### 6. Hugging Face Metadata
+
+Add Hugging Face metadata to your `README.md`:
+
+```markdown
+---
+title: Lin - LinkedIn Community Manager
+sdk: docker
+app_file: app.py
+license: mit
+---
+```
+
+### 7. Docker Configuration (Optional)
+
+If you want more control over the deployment environment, create a `Dockerfile`:
+
+```dockerfile
+FROM python:3.10
+
+WORKDIR /app
+
+# Install Node.js for frontend build
+RUN curl -fsSL https://deb.nodesource.com/setup_16.x | bash -
+RUN apt-get update && apt-get install -y nodejs
+
+# Copy and install Python dependencies
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+# Copy package files for frontend
+COPY frontend/package*.json ./frontend/
+# Install frontend dependencies
+RUN cd frontend && npm install
+
+# Copy all files
+COPY . .
+
+# Build frontend
+RUN cd frontend && npm run build
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"]
+```
+
+### 8. Deploy to Hugging Face Spaces
+
+1. Create a new Space on Hugging Face:
+   - Go to https://huggingface.co/new-space
+   - Choose "Python (Docker)" as the SDK
+   - Give your Space a name
+
+2. Push your code via Git:
+   ```bash
+   git init
+   git remote add origin https://huggingface.co/spaces/<username>/<space-name>
+   git add .
+   git commit -m "Deploy to Hugging Face Spaces"
+   git push origin main
+   ```
+
+## How It Works
+
+1. Hugging Face installs Python and Node.js dependencies
+2. During the build process, it runs `npm run build` in the frontend directory
+3. It installs Python dependencies from `requirements.txt`
+4. It runs `python app.py`
+5. Flask serves both:
+   - Your API endpoints (e.g., `/api/*`)
+   - Your compiled React frontend (static files from `frontend/dist`)
+
+## Scheduler (Celery) Considerations
+
+Your application uses Celery for scheduling tasks. On Hugging Face Spaces:
+
+1. **Celery Worker and Beat** can run in the same container as your Flask app
+2. **Redis** is used as the broker and result backend
+3. **Task Persistence** is handled through the database, not just the Celery schedule file
+
+The scheduler will work, but you should be aware that:
+- Hugging Face Spaces might put your app to sleep after periods of inactivity
+- When the app wakes up, the Celery processes will restart
+- Your schedules are stored in the database, so they will be reloaded when the app restarts
+
+## Access Your Application
+
+After deployment, your app will be available at:
+`https://zelyanoth-lin.hf.space`
+
+## Troubleshooting
+
+1. **Frontend not loading**: Ensure you've run `npm run build` and committed the `dist/` folder
+2. **API calls failing**: Check that your `VITE_API_URL` points to the correct Space URL
+3. **OAuth issues**: Verify that your redirect URL in both the `.env` file and LinkedIn Developer Console match your Space URL
+4. **Build errors**: Check the build logs in your Space's "Files" tab for detailed error messages
+5. **Scheduler not working**: Check that Redis is available and that Celery processes are running
+
+## Additional Notes
+
+- Hugging Face Spaces has resource limitations, so optimize your application accordingly
+- For production use with significant traffic, consider using a more robust hosting solution
+- Regularly update your dependencies to ensure security patches
+- Monitor your Space's logs for any runtime errors

IMPLEMENTATION_SUMMARY.md

@@ -0,0 +1,215 @@
+# Lin React Clone Implementation Summary
+
+## Overview
+
+This document provides a summary of the implementation of the React clone of the Lin application with a Flask API backend. The implementation follows the architecture designed in the planning phase and includes both frontend and backend components.
+
+## Backend Implementation (Flask API)
+
+### Project Structure
+The backend follows a modular structure with clear separation of concerns:
+- `app.py` - Main application entry point with Flask initialization
+- `config.py` - Configuration management
+- `models/` - Data models for all entities
+- `api/` - RESTful API endpoints organized by feature
+- `services/` - Business logic and external API integrations
+- `utils/` - Utility functions and helpers
+- `scheduler/` - Task scheduling implementation
+- `requirements.txt` - Python dependencies
+
+### Key Features Implemented
+
+#### Authentication System
+- JWT-based authentication with secure token management
+- User registration with email confirmation
+- User login/logout functionality
+- Password hashing with bcrypt
+- Supabase Auth integration
+
+#### Source Management
+- CRUD operations for RSS sources
+- Integration with Supabase database
+- Validation and error handling
+
+#### Social Account Management
+- LinkedIn OAuth2 integration
+- Account linking and token storage
+- Profile information retrieval
+
+#### Post Management
+- AI-powered content generation using Hugging Face API
+- Post creation and storage
+- LinkedIn publishing integration
+- Image handling for posts
+
+#### Scheduling System
+- APScheduler for task management
+- Recurring schedule creation
+- Automatic content generation and publishing
+- Conflict resolution for overlapping schedules
+
+### API Endpoints
+All endpoints follow REST conventions:
+- Authentication: `/api/auth/*`
+- Sources: `/api/sources/*`
+- Accounts: `/api/accounts/*`
+- Posts: `/api/posts/*`
+- Schedules: `/api/schedules/*`
+
+## Frontend Implementation (React)
+
+### Project Structure
+The frontend follows a component-based architecture:
+- `components/` - Reusable UI components
+- `pages/` - Page-level components corresponding to routes
+- `services/` - API service layer
+- `store/` - Redux store with reducers and actions
+- `App.js` - Main application component
+- `index.js` - Entry point
+
+### Key Features Implemented
+
+#### Authentication System
+- Login and registration forms
+- JWT token management in localStorage
+- Protected routes
+- User session management
+
+#### Dashboard
+- Overview statistics
+- Recent activity display
+- Quick action buttons
+
+#### Source Management
+- Add/delete RSS sources
+- List view of all sources
+- Form validation
+
+#### Post Management
+- AI content generation interface
+- Post creation form
+- Draft and published post management
+- Publish and delete functionality
+
+#### Scheduling
+- Schedule creation form with time selection
+- Day selection interface
+- List view of all schedules
+- Delete functionality
+
+### State Management
+- Redux Toolkit for global state management
+- Async thunks for API calls
+- Loading and error states
+- Slice-based organization
+
+### UI/UX Features
+- Responsive design for all device sizes
+- Consistent color scheme based on brand colors
+- Material-UI components
+- Form validation and error handling
+- Loading states and user feedback
+
+## Integration Points
+
+### Backend-Frontend Communication
+- RESTful API endpoints
+- JSON request/response format
+- JWT token authentication
+- CORS support
+
+### External Services
+- Supabase for database and authentication
+- LinkedIn API for social media integration
+- Hugging Face API for content generation
+- APScheduler for task management
+
+## Technologies Used
+
+### Backend
+- Flask (Python web framework)
+- Supabase (Database and authentication)
+- APScheduler (Task scheduling)
+- requests (HTTP library)
+- requests-oauthlib (OAuth support)
+- gradio-client (Hugging Face API)
+- Flask-JWT-Extended (JWT token management)
+
+### Frontend
+- React (JavaScript library)
+- Redux Toolkit (State management)
+- React Router (Routing)
+- Axios (HTTP client)
+- Material-UI (UI components)
+
+## Deployment Considerations
+
+### Backend
+- Docker support with Dockerfile
+- Environment variable configuration
+- Health check endpoint
+- Error logging and monitoring
+
+### Frontend
+- Static asset optimization
+- Environment variable configuration
+- Responsive design
+- Accessibility features
+
+## Testing
+
+### Backend
+- Unit tests for services
+- Integration tests for API endpoints
+- Database integration tests
+
+### Frontend
+- Component rendering tests
+- Redux action and reducer tests
+- Form submission tests
+- Routing tests
+
+## Security Features
+
+### Backend
+- JWT token authentication
+- Input validation and sanitization
+- Secure password hashing
+- CORS policy configuration
+
+### Frontend
+- Secure token storage
+- Protected routes
+- Form validation
+- Error handling
+
+## Performance Optimizations
+
+### Backend
+- Database connection pooling
+- Caching strategies
+- Efficient query design
+
+### Frontend
+- Component memoization
+- Lazy loading
+- Bundle optimization
+- Image optimization
+
+## Future Enhancements
+
+### Backend
+- Advanced analytics and reporting
+- Additional social media platform support
+- Enhanced scheduling algorithms
+- Performance monitoring
+
+### Frontend
+- Advanced data visualization
+- Real-time updates with WebSockets
+- Enhanced accessibility features
+- Additional UI components
+
+## Conclusion
+
+The React clone of the Lin application has been successfully implemented with a clear separation between the frontend and backend. The implementation follows modern best practices for both Flask and React development, with a focus on maintainability, scalability, and security. The application includes all core features of the original Taipy application with an improved architecture that allows for easier maintenance and future enhancements.

LINKEDIN_AUTH_GUIDE.md

@@ -0,0 +1,258 @@
+# LinkedIn Authentication Implementation Guide
+
+This guide provides a comprehensive overview of the LinkedIn authentication implementation in the React Clone application.
+
+## Overview
+
+The LinkedIn authentication system allows users to connect multiple LinkedIn accounts to the application for posting content. The implementation follows OAuth 2.0 standards and includes proper error handling, state management, and user experience considerations.
+
+## Architecture
+
+### Frontend Components
+
+1. **LinkedInAuthService** (`frontend/src/services/linkedinAuthService.js`)
+   - Handles all API calls related to LinkedIn authentication
+   - Manages OAuth flow initiation and callback processing
+   - Provides methods for account management
+
+2. **LinkedInAccountsSlice** (`frontend/src/store/reducers/linkedinAccountsSlice.js`)
+   - Redux slice for managing LinkedIn accounts state
+   - Handles async operations for fetching, adding, and managing accounts
+   - Manages loading states and error handling
+
+3. **LinkedInAccountsManager** (`frontend/src/components/LinkedInAccount/LinkedInAccountsManager.js`)
+   - Main component for managing LinkedIn accounts
+   - Displays connected accounts and provides management options
+   - Handles the "Add Account" flow
+
+4. **LinkedInAccountCard** (`frontend/src/components/LinkedInAccount/LinkedInAccountCard.js`)
+   - Individual account display component
+   - Shows account information and actions (set primary, delete)
+   - Handles account-specific operations
+
+5. **LinkedInCallbackHandler** (`frontend/src/components/LinkedInAccount/LinkedInCallbackHandler.js`)
+   - Handles the OAuth callback from LinkedIn
+   - Processes authorization code and exchanges it for access token
+   - Manages authentication states and error handling
+
+6. **Accounts Page** (`frontend/src/pages/Accounts.js`)
+   - Dedicated page for managing all social media accounts
+   - Provides a clean interface for LinkedIn account management
+   - Separates account management from RSS source management
+
+### Backend API
+
+1. **Accounts API** (`backend/api/accounts.py`)
+   - `/accounts` - GET: Fetch all accounts, POST: Initiate OAuth flow
+   - `/accounts/callback` - POST: Handle OAuth callback
+   - `/accounts/{id}` - DELETE: Remove account
+   - `/accounts/{id}/primary` - PUT: Set account as primary
+
+2. **LinkedInService** (`backend/services/linkedin_service.py`)
+   - Handles LinkedIn API interactions
+   - Manages OAuth token exchange
+   - Provides methods for user info retrieval and posting
+
+## Implementation Details
+
+### OAuth Flow
+
+1. **Initiation**
+   - User clicks "Add LinkedIn Account" button on the Accounts page
+   - Frontend calls `/accounts` endpoint with `social_network: 'LinkedIn'`
+   - Backend generates authorization URL and state parameter
+   - User is redirected to LinkedIn for authentication
+
+2. **Callback Handling**
+   - LinkedIn redirects back to `/linkedin/callback` with authorization code
+   - Frontend processes the callback and exchanges code for access token
+   - Backend validates the code and retrieves user information
+   - Account information is stored in the database
+
+3. **Account Management**
+   - Users can view all connected LinkedIn accounts on the Accounts page
+   - Primary account can be set for posting operations
+   - Accounts can be disconnected (deleted)
+
+### State Management
+
+The Redux store manages the following states for LinkedIn accounts:
+
+```javascript
+{
+  linkedinAccounts: {
+    items: [],           // Array of LinkedIn accounts
+    loading: false,      // Loading state
+    error: null,         // Error message
+    oauthLoading: false, // OAuth process loading
+    oauthError: null,    // OAuth error message
+    deletingAccount: null, // ID of account being deleted
+    settingPrimary: null   // ID of account being set as primary
+  }
+}
+```
+
+### Database Schema
+
+LinkedIn accounts are stored in the `Social_network` table with the following fields:
+
+- `id`: Unique identifier
+- `social_network`: 'LinkedIn'
+- `account_name`: Display name for the account
+- `id_utilisateur`: User ID (foreign key)
+- `token`: LinkedIn access token
+- `sub`: LinkedIn user ID
+- `given_name`: User's first name
+- `family_name`: User's last name
+- `picture`: Profile picture URL
+- `is_primary`: Boolean flag for primary account
+
+## Usage Instructions
+
+### Adding a LinkedIn Account
+
+1. Navigate to the **Accounts** page (`/accounts`)
+2. Click **"Add LinkedIn Account"**
+3. Follow the LinkedIn authentication flow
+4. After successful authentication, the account will appear in the list
+
+### Managing LinkedIn Accounts
+
+1. **View Accounts**: All connected accounts are displayed on the Accounts page
+2. **Set Primary**: Click "Set Primary" on the desired account
+3. **Disconnect**: Click "Disconnect" to remove an account (confirmation required)
+
+### Page Structure
+
+- **Sources Page** (`/sources`): Dedicated to RSS source management only
+- **Accounts Page** (`/accounts`): Dedicated to social media account management
+
+### Error Handling
+
+The implementation includes comprehensive error handling:
+
+- **OAuth Errors**: Invalid state, expired authorization codes
+- **Network Errors**: API timeouts, connection issues
+- **Authentication Errors**: Invalid tokens, permission denied
+- **Database Errors**: Failed storage operations
+
+### Security Considerations
+
+1. **State Parameter**: Randomly generated state parameter for CSRF protection
+2. **Token Storage**: Access tokens are stored securely in the database
+3. **User Validation**: All operations are validated against the authenticated user
+4. **HTTPS**: All API calls use HTTPS for secure communication
+
+## Configuration
+
+### Environment Variables
+
+Ensure the following environment variables are set:
+
+```bash
+# LinkedIn OAuth Configuration
+CLIENT_ID=your_linkedin_client_id
+CLIENT_SECRET=your_linkedin_client_secret
+REDIRECT_URL=your_redirect_url
+
+# Supabase Configuration
+SUPABASE_URL=your_supabase_url
+SUPABASE_KEY=your_supabase_key
+```
+
+### Backend Configuration
+
+The backend uses the following LinkedIn API endpoints:
+
+- Authorization: `https://www.linkedin.com/oauth/v2/authorization`
+- Token Exchange: `https://www.linkedin.com/oauth/v2/accessToken`
+- User Info: `https://api.linkedin.com/v2/userinfo`
+
+## Testing
+
+### Manual Testing Steps
+
+1. **Account Addition**
+   - Navigate to Accounts page
+   - Click "Add LinkedIn Account"
+   - Complete OAuth flow
+   - Verify account appears in the list
+
+2. **Account Management**
+   - Test setting primary account
+   - Test disconnecting accounts
+   - Verify error states and loading indicators
+
+3. **Page Navigation**
+   - Verify Sources page only shows RSS sources
+   - Verify Accounts page only shows social media accounts
+   - Test navigation between pages
+
+### Automated Testing
+
+The implementation includes Redux action and reducer tests that can be extended with:
+
+- OAuth flow simulation
+- API mocking
+- State validation
+- Error condition testing
+
+## Troubleshooting
+
+### Common Issues
+
+1. **OAuth State Mismatch**
+   - Ensure state parameter is properly generated and stored
+   - Check for proper state validation in callback handling
+
+2. **Token Exchange Failures**
+   - Verify client ID and client secret are correct
+   - Ensure redirect URL matches configuration
+   - Check for expired authorization codes
+
+3. **Account Not Displaying**
+   - Verify database insertion was successful
+   - Check user ID mapping
+   - Ensure API response is properly formatted
+
+4. **Page Navigation Issues**
+   - Verify routes are properly configured in App.js
+   - Check that components are imported correctly
+   - Ensure Redux state is properly connected
+
+### Debug Mode
+
+Enable debug logging by setting:
+
+```javascript
+// In development mode
+localStorage.setItem('debug', 'linkedin:*');
+
+// Backend logging
+export DEBUG=True
+```
+
+## Future Enhancements
+
+1. **Token Refresh**: Implement automatic token refresh
+2. **Account Permissions**: Request specific LinkedIn permissions
+3. **Batch Operations**: Support for managing multiple accounts simultaneously
+4. **Analytics**: Track account usage and posting statistics
+5. **Webhooks**: Implement LinkedIn webhook support for real-time updates
+6. **Additional Social Networks**: Extend to Twitter, Facebook, etc.
+
+## Support
+
+For issues or questions regarding the LinkedIn authentication implementation:
+
+1. Check the troubleshooting section above
+2. Review browser console and network tab for errors
+3. Check backend logs for API-related issues
+4. Verify environment configuration
+5. Ensure proper page navigation and routing
+
+## References
+
+- [LinkedIn OAuth 2.0 Documentation](https://learn.microsoft.com/en-us/linkedin/consumer/integrations/self-serve/sign-in-with-linkedin)
+- [React Redux Toolkit Documentation](https://redux-toolkit.js.org/)
+- [OAuth 2.0 Framework](https://datatracker.ietf.org/doc/html/rfc6749)

REACT_DEVELOPMENT_GUIDE.md

@@ -0,0 +1,568 @@
+# React Development Guide for Lin Project
+
+## Overview
+
+This guide documents the React development patterns, best practices, and conventions used in the Lin project. It serves as a reference for current and future developers working on the frontend.
+
+## Project Structure
+
+The frontend follows a component-based architecture with clear separation of concerns:
+
+```
+frontend/
+├── src/
+│   ├── components/        # Reusable UI components
+│   │   ├── Header/        # Header component
+│   │   ├── Sidebar/       # Sidebar navigation
+│   │   └── ...            # Other reusable components
+│   ├── pages/             # Page-level components
+│   ├── services/          # API service layer
+│   ├── store/             # Redux store configuration
+│   ├── App.jsx            # Root component
+│   └── index.jsx          # Entry point
+├── public/                # Static assets
+└── package.json           # Dependencies and scripts
+```
+
+## Core Technologies
+
+- React 18+ with Hooks
+- React Router v6 for routing
+- Redux Toolkit for state management
+- Axios for HTTP requests
+- Tailwind CSS for styling
+- Material Icons for icons
+
+## Component Development Patterns
+
+### Functional Components with Hooks
+
+All components are implemented as functional components using React hooks:
+
+```jsx
+import React, { useState, useEffect } from 'react';
+
+const MyComponent = ({ prop1, prop2 }) => {
+  const [state, setState] = useState(initialValue);
+  
+  useEffect(() => {
+    // Side effects
+  }, [dependencies]);
+  
+  return (
+    <div className="component-class">
+      {/* JSX */}
+    </div>
+  );
+};
+
+export default MyComponent;
+```
+
+### Component Structure
+
+1. **Imports** - All necessary imports at the top
+2. **Component Definition** - Functional component with destructured props
+3. **State Management** - useState, useEffect, and custom hooks
+4. **Helper Functions** - Small utility functions within the component
+5. **JSX Return** - Clean, semantic HTML with Tailwind classes
+6. **Export** - Default export of the component
+
+### State Management
+
+#### Local Component State
+
+Use `useState` for local component state:
+
+```jsx
+const [isOpen, setIsOpen] = useState(false);
+const [data, setData] = useState([]);
+const [loading, setLoading] = useState(false);
+```
+
+#### Global State (Redux)
+
+Use Redux Toolkit for global state management. Structure slices by feature:
+
+```jsx
+// store/reducers/featureSlice.js
+import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
+
+export const fetchFeatureData = createAsyncThunk(
+  'feature/fetchData',
+  async (params) => {
+    const response = await api.getFeatureData(params);
+    return response.data;
+  }
+);
+
+const featureSlice = createSlice({
+  name: 'feature',
+  initialState: {
+    items: [],
+    loading: false,
+    error: null
+  },
+  reducers: {
+    clearError: (state) => {
+      state.error = null;
+    }
+  },
+  extraReducers: (builder) => {
+    builder
+      .addCase(fetchFeatureData.pending, (state) => {
+        state.loading = true;
+      })
+      .addCase(fetchFeatureData.fulfilled, (state, action) => {
+        state.loading = false;
+        state.items = action.payload;
+      })
+      .addCase(fetchFeatureData.rejected, (state, action) => {
+        state.loading = false;
+        state.error = action.error.message;
+      });
+  }
+});
+
+export const { clearError } = featureSlice.actions;
+export default featureSlice.reducer;
+```
+
+### Props and Prop Types
+
+Destructure props in the component signature and provide default values when appropriate:
+
+```jsx
+const MyComponent = ({ 
+  title, 
+  items = [], 
+  isLoading = false, 
+  onAction = () => {} 
+}) => {
+  // Component implementation
+};
+```
+
+### Event Handling
+
+Use inline arrow functions or separate handler functions:
+
+```jsx
+// Inline
+<button onClick={() => handleClick(item.id)}>Click me</button>
+
+// Separate function
+const handleDelete = (id) => {
+  dispatch(deleteItem(id));
+};
+
+<button onClick={() => handleDelete(item.id)}>Delete</button>
+```
+
+## Styling with Tailwind CSS
+
+The project uses Tailwind CSS for styling. Follow these conventions:
+
+### Class Organization
+
+1. **Layout classes** (flex, grid, etc.) first
+2. **Positioning** (relative, absolute, etc.)
+3. **Sizing** (w-, h-, etc.)
+4. **Spacing** (m-, p-, etc.)
+5. **Typography** (text-, font-, etc.)
+6. **Visual** (bg-, border-, shadow-, etc.)
+7. **Interactive states** (hover:, focus:, etc.)
+
+```jsx
+<div className="flex items-center justify-between w-full p-4 bg-white rounded-lg shadow hover:shadow-md focus:outline-none focus:ring-2 focus:ring-primary-500">
+  {/* Content */}
+</div>
+```
+
+### Responsive Design
+
+Use Tailwind's responsive prefixes (sm:, md:, lg:, xl:) for responsive styles:
+
+```jsx
+<div className="flex flex-col lg:flex-row items-center p-4 sm:p-6">
+  <div className="w-full lg:w-1/2 mb-4 lg:mb-0 lg:mr-6">
+    {/* Content */}
+  </div>
+  <div className="w-full lg:w-1/2">
+    {/* Content */}
+  </div>
+</div>
+```
+
+### Custom Classes
+
+For complex components, use component-specific classes in conjunction with Tailwind:
+
+```jsx
+<NavLink 
+  to={item.path}
+  className={({ isActive }) => `
+    nav-link group relative flex items-center px-3 py-2.5 text-sm font-medium rounded-lg
+    transition-all duration-200 ease-in-out
+    ${isActive 
+      ? 'bg-gradient-to-r from-primary-600 to-primary-700 text-white' 
+      : 'text-secondary-700 hover:bg-accent-100'
+    }
+  `}
+>
+```
+
+## Routing
+
+Use React Router v6 for navigation:
+
+```jsx
+import { Routes, Route, useNavigate, useLocation } from 'react-router-dom';
+
+// In App.jsx
+<Routes>
+  <Route path="/dashboard" element={<Dashboard />} />
+  <Route path="/sources" element={<Sources />} />
+  <Route path="/posts" element={<Posts />} />
+  <Route path="/schedule" element={<Schedule />} />
+</Routes>
+
+// In components
+const navigate = useNavigate();
+const location = useLocation();
+
+// Navigation
+navigate('/dashboard');
+
+// Check current route
+if (location.pathname === '/dashboard') {
+  // Do something
+}
+```
+
+## API Integration
+
+### Service Layer
+
+Create service functions for API calls:
+
+```jsx
+// services/api.js
+import axios from 'axios';
+
+const API_BASE_URL = process.env.REACT_APP_API_URL || 'http://localhost:5000';
+
+const api = axios.create({
+  baseURL: API_BASE_URL,
+  timeout: 10000,
+});
+
+// Request interceptor
+api.interceptors.request.use((config) => {
+  const token = localStorage.getItem('token');
+  if (token) {
+    config.headers.Authorization = `Bearer ${token}`;
+  }
+  return config;
+});
+
+// Response interceptor
+api.interceptors.response.use(
+  (response) => response,
+  (error) => {
+    if (error.response?.status === 401) {
+      // Handle unauthorized access
+      localStorage.removeItem('token');
+      window.location.href = '/login';
+    }
+    return Promise.reject(error);
+  }
+);
+
+export default api;
+
+// services/featureService.js
+import api from './api';
+
+export const getFeatures = async () => {
+  const response = await api.get('/api/features');
+  return response.data;
+};
+
+export const createFeature = async (data) => {
+  const response = await api.post('/api/features', data);
+  return response.data;
+};
+```
+
+### Async Operations with Redux Thunks
+
+Use createAsyncThunk for asynchronous operations:
+
+```jsx
+// In slice
+export const fetchData = createAsyncThunk(
+  'feature/fetchData',
+  async (_, { rejectWithValue }) => {
+    try {
+      const data = await featureService.getFeatures();
+      return data;
+    } catch (error) {
+      return rejectWithValue(error.response.data);
+    }
+  }
+);
+
+// In component
+const dispatch = useDispatch();
+const { items, loading, error } = useSelector(state => state.feature);
+
+useEffect(() => {
+  dispatch(fetchData());
+}, [dispatch]);
+```
+
+## Accessibility (a11y)
+
+Implement proper accessibility features:
+
+1. **Semantic HTML** - Use appropriate HTML elements
+2. **ARIA attributes** - When needed for dynamic content
+3. **Keyboard navigation** - Ensure all interactive elements are keyboard accessible
+4. **Focus management** - Proper focus handling for modals, dropdowns, etc.
+5. **Screen reader support** - Use aria-label, aria-describedby, etc.
+
+```jsx
+<button 
+  aria-label="Close dialog"
+  aria-expanded={isOpen}
+  onClick={handleClose}
+>
+  ✕
+</button>
+
+<nav aria-label="Main navigation">
+  <ul role="menubar">
+    <li role="none">
+      <a 
+        href="/dashboard" 
+        role="menuitem"
+        aria-current={currentPage === 'dashboard' ? 'page' : undefined}
+      >
+        Dashboard
+      </a>
+    </li>
+  </ul>
+</nav>
+```
+
+## Performance Optimization
+
+### Memoization
+
+Use React.memo for components that render frequently:
+
+```jsx
+const MyComponent = React.memo(({ data, onUpdate }) => {
+  // Component implementation
+});
+
+export default MyComponent;
+```
+
+### useCallback and useMemo
+
+Optimize expensive calculations and callback functions:
+
+```jsx
+const expensiveValue = useMemo(() => {
+  return computeExpensiveValue(data);
+}, [data]);
+
+const handleClick = useCallback((id) => {
+  dispatch(action(id));
+}, [dispatch]);
+```
+
+### Lazy Loading
+
+Use React.lazy for code splitting:
+
+```jsx
+import { lazy, Suspense } from 'react';
+
+const LazyComponent = lazy(() => import('./components/MyComponent'));
+
+<Suspense fallback={<div>Loading...</div>}>
+  <LazyComponent />
+</Suspense>
+```
+
+## Error Handling
+
+### Error Boundaries
+
+Implement error boundaries for catching JavaScript errors:
+
+```jsx
+class ErrorBoundary extends React.Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false };
+  }
+
+  static getDerivedStateFromError(error) {
+    return { hasError: true };
+  }
+
+  componentDidCatch(error, errorInfo) {
+    console.error('Error caught by boundary:', error, errorInfo);
+  }
+
+  render() {
+    if (this.state.hasError) {
+      return <h1>Something went wrong.</h1>;
+    }
+
+    return this.props.children;
+  }
+}
+
+// Usage
+<ErrorBoundary>
+  <MyComponent />
+</ErrorBoundary>
+```
+
+### API Error Handling
+
+Handle API errors gracefully:
+
+```jsx
+const [error, setError] = useState(null);
+
+const handleSubmit = async (data) => {
+  try {
+    setError(null);
+    const result = await api.createItem(data);
+    // Handle success
+  } catch (err) {
+    setError(err.response?.data?.message || 'An error occurred');
+  }
+};
+
+{error && (
+  <div className="text-red-500 text-sm mt-2">
+    {error}
+  </div>
+)}
+```
+
+## Testing
+
+### Unit Testing
+
+Use Jest and React Testing Library for unit tests:
+
+```jsx
+import { render, screen, fireEvent } from '@testing-library/react';
+import MyComponent from './MyComponent';
+
+test('renders component with title', () => {
+  render(<MyComponent title="Test Title" />);
+  expect(screen.getByText('Test Title')).toBeInTheDocument();
+});
+
+test('calls onClick when button is clicked', () => {
+  const handleClick = jest.fn();
+  render(<MyComponent onClick={handleClick} />);
+  fireEvent.click(screen.getByRole('button'));
+  expect(handleClick).toHaveBeenCalledTimes(1);
+});
+```
+
+### Redux Testing
+
+Test Redux slices and async thunks:
+
+```jsx
+import featureReducer, { fetchData } from './featureSlice';
+
+test('handles fulfilled fetch data', () => {
+  const initialState = { items: [], loading: false, error: null };
+  const data = [{ id: 1, name: 'Test' }];
+  const action = { type: fetchData.fulfilled, payload: data };
+  const state = featureReducer(initialState, action);
+  expect(state.items).toEqual(data);
+  expect(state.loading).toBe(false);
+});
+```
+
+## Mobile Responsiveness
+
+### Touch Optimization
+
+Add touch-specific classes and handlers:
+
+```jsx
+<button 
+  className="touch-manipulation active:scale-95"
+  onTouchStart={handleTouchStart}
+  onTouchEnd={handleTouchEnd}
+>
+  Click me
+</button>
+```
+
+### Responsive Breakpoints
+
+Use Tailwind's responsive utilities for different screen sizes:
+
+- Mobile: Default styles (0-767px)
+- Tablet: `sm:` (768px+) and `md:` (1024px+)
+- Desktop: `lg:` (1280px+) and `xl:` (1536px+)
+
+### Mobile-First Approach
+
+Start with mobile styles and enhance for larger screens:
+
+```jsx
+<div className="flex flex-col lg:flex-row">
+  <div className="w-full lg:w-1/2">
+    {/* Content that stacks on mobile, side-by-side on desktop */}
+  </div>
+</div>
+```
+
+## Best Practices
+
+### Component Design
+
+1. **Single Responsibility** - Each component should have one clear purpose
+2. **Reusability** - Design components to be reusable across the application
+3. **Composition** - Build complex UIs by composing simpler components
+4. **Controlled Components** - Prefer controlled components for form elements
+5. **Props Drilling** - Use context or Redux to avoid excessive prop drilling
+
+### Code Organization
+
+1. **Consistent Naming** - Use consistent naming conventions (PascalCase for components)
+2. **Logical Grouping** - Group related files in directories
+3. **Export Strategy** - Use default exports for components, named exports for utilities
+4. **Import Organization** - Group imports logically (external, internal, styles)
+
+### Performance
+
+1. **Bundle Size** - Monitor bundle size and optimize when necessary
+2. **Rendering** - Use React.memo, useMemo, and useCallback appropriately
+3. **API Calls** - Implement caching and pagination where appropriate
+4. **Images** - Optimize images and use lazy loading
+
+### Security
+
+1. **XSS Prevention** - React automatically escapes content, but be careful with dangerouslySetInnerHTML
+2. **Token Storage** - Store JWT tokens securely (HttpOnly cookies or secure localStorage)
+3. **Input Validation** - Validate and sanitize user inputs
+4. **CORS** - Ensure proper CORS configuration on the backend
+
+This guide should help maintain consistency and quality across the React frontend implementation in the Lin project.

README.md

@@ -1,10 +1,311 @@
 ---
-title: Lin
-emoji: 📊
-colorFrom: purple
-colorTo: indigo
+title: Lin - LinkedIn Community Manager
 sdk: docker
-pinned: false
+app_file: app.py
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Lin - Community Manager Assistant for LinkedIn
+
+A comprehensive community management tool that helps you automate and streamline your LinkedIn activities.
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Node.js (v16 or higher)
+- Python (v3.8 or higher)
+- npm (v8 or higher)
+
+### Installation
+
+**Option 1: Using the root package.json (Recommended)**
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd Lin
+
+# Install all dependencies
+npm install
+
+# Setup the project
+npm run setup
+
+# Start both frontend and backend
+npm start
+```
+
+**Option 2: Manual installation**
+
+```bash
+# Install frontend dependencies
+cd frontend
+npm install
+
+# Install backend dependencies
+cd ../backend
+pip install -r requirements.txt
+
+# Return to root directory
+cd ..
+```
+
+## 📁 Project Structure
+
+```
+Lin/
+├── package.json              # Root package.json with combined scripts
+├── frontend/                 # React frontend application
+│   ├── package.json          # Frontend-specific dependencies
+│   ├── src/                  # React source code
+│   ├── public/               # Static assets
+│   └── build/                # Build output
+├── backend/                  # Flask backend API
+│   ├── app.py                # Main application file
+│   ├── requirements.txt      # Python dependencies
+│   ├── api/                  # API endpoints
+│   ├── models/               # Data models
+│   ├── services/             # Business logic
+│   └── utils/                # Utility functions
+└── README.md                 # This file
+```
+
+## 🛠️ Development
+
+### Available Scripts
+
+From the project root directory, you can use the following commands:
+
+#### Installation
+- `npm install` - Install root dependencies
+- `npm run install:frontend` - Install frontend dependencies
+- `npm run install:backend` - Install backend dependencies
+- `npm run install:all` - Install all dependencies
+- `npm run install:all:win` - Install all dependencies (Windows-specific)
+
+#### Development Servers
+- `npm run dev:frontend` - Start frontend development server
+- `npm run dev:backend` - Start backend development server
+- `npm run dev:all` - Start both servers concurrently
+- `npm run start` - Alias for `npm run dev:all`
+- `npm run start:frontend` - Start frontend only
+- `npm run start:backend` - Start backend only
+
+#### Build & Test
+- `npm run build` - Build frontend for production
+- `npm run build:prod` - Build frontend for production
+- `npm run preview` - Preview production build
+- `npm run test` - Run frontend tests
+- `npm run test:backend` - Run backend tests
+- `npm run lint` - Run ESLint
+- `npm run lint:fix` - Fix ESLint issues
+
+#### Setup & Maintenance
+- `npm run setup` - Full setup (install + build)
+- `npm run setup:win` - Full setup (Windows-specific)
+- `npm run clean` - Clean build artifacts
+- `npm run reset` - Reset project (clean + install)
+
+### Directory Navigation
+
+**Important:** Most npm commands should be run from the project root directory where the main `package.json` is located.
+
+#### Command Prompt (Windows)
+```cmd
+# Navigate to project root (if not already there)
+cd C:\Users\YourUser\Documents\Project\Lin_re\Lin
+
+# Install dependencies
+npm install
+
+# Start development servers
+npm start
+
+# Or start individually
+npm run dev:frontend
+npm run dev:backend
+```
+
+#### PowerShell (Windows)
+```powershell
+# Navigate to project root (if not already there)
+cd C:\Users\YourUser\Documents\Project\Lin_re\Lin
+
+# Install dependencies
+npm install
+
+# Start development servers
+npm start
+
+# Or start individually
+npm run dev:frontend
+npm run dev:backend
+```
+
+#### Linux/macOS
+```bash
+# Navigate to project root (if not already there)
+cd /path/to/your/project/Lin
+
+# Install dependencies
+npm install
+
+# Start development servers
+npm start
+
+# Or start individually
+npm run dev:frontend
+npm run dev:backend
+```
+
+## 🔧 Environment Setup
+
+### Frontend Environment
+
+```bash
+# Copy environment file
+cd frontend
+cp .env.example .env.local
+
+# Edit environment variables
+# Open .env.local and add your required values
+```
+
+### Backend Environment
+
+```bash
+# Copy environment file
+cd backend
+cp .env.example .env
+
+# Edit environment variables
+# Open .env and add your required values
+```
+
+### Required Environment Variables
+
+**Frontend (.env.local)**
+- `REACT_APP_API_URL` - Backend API URL (default: http://localhost:5000)
+
+**Backend (.env)**
+- `SUPABASE_URL` - Your Supabase project URL
+- `SUPABASE_KEY` - Your Supabase API key
+- `CLIENT_ID` - LinkedIn OAuth client ID
+- `CLIENT_SECRET` - LinkedIn OAuth client secret
+- `REDIRECT_URL` - LinkedIn OAuth redirect URL
+- `HUGGING_KEY` - Hugging Face API key
+- `JWT_SECRET_KEY` - Secret key for JWT token generation
+- `SECRET_KEY` - Flask secret key
+- `DEBUG` - Debug mode (True/False)
+- `SCHEDULER_ENABLED` - Enable/disable task scheduler (True/False)
+- `PORT` - Port to run the application on (default: 5000)
+
+## 🌐 Development URLs
+
+- **Frontend**: http://localhost:3000
+- **Backend API**: http://localhost:5000
+
+## 🔍 Troubleshooting
+
+### Common Issues
+
+#### 1. ENOENT Error: no such file or directory
+**Problem**: Running npm commands from the wrong directory
+**Solution**: Always run npm commands from the project root directory where `package.json` is located
+
+```bash
+# Check if you're in the right directory
+ls package.json
+
+# If not, navigate to the root directory
+cd /path/to/project/Lin
+```
+
+#### 2. Port Already in Use
+**Problem**: Port 3000 or 5000 is already in use
+**Solution**: Change ports or stop conflicting services
+
+**Command Prompt:**
+```cmd
+# Check what's using port 3000
+netstat -ano | findstr :3000
+
+# Check what's using port 5000
+netstat -ano | findstr :5000
+```
+
+**PowerShell:**
+```powershell
+# Check what's using port 3000
+netstat -ano | Select-String ":3000"
+
+# Check what's using port 5000
+netstat -ano | Select-String ":5000"
+```
+
+#### 3. Python/Node.js Not Recognized
+**Problem**: Python or Node.js commands not found
+**Solution**: Ensure Python and Node.js are added to your system PATH
+
+**Windows:**
+1. Open System Properties > Environment Variables
+2. Add Python and Node.js installation directories to PATH
+3. Restart your terminal
+
+#### 4. Permission Issues
+**Problem**: Permission denied errors
+**Solution**: Run terminal as Administrator or check file permissions
+
+### Windows-Specific Issues
+
+#### File Copy Commands
+**Command Prompt:**
+```cmd
+# Copy frontend environment file
+copy frontend\.env.example frontend\.env.local
+
+# Copy backend environment file
+copy backend\.env.example backend\.env
+```
+
+**PowerShell:**
+```powershell
+# Copy frontend environment file
+Copy-Item frontend\.env.example -Destination frontend\.env.local
+
+# Copy backend environment file
+Copy-Item backend\.env.example -Destination backend\.env
+```
+
+#### Python Installation Issues
+```cmd
+# If pip fails, try using python -m pip
+cd backend
+python -m pip install -r requirements.txt
+```
+
+## 📚 Additional Resources
+
+- [Windows Compatibility Guide](./test_windows_compatibility.md)
+- [Backend API Documentation](./backend/README.md)
+- [Frontend Development Guide](./frontend/README.md)
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Built with React, Flask, and Tailwind CSS
+- Powered by Supabase for authentication and database
+- LinkedIn API integration for social media management
+- Hugging Face for AI-powered content generation

SETUP_GUIDE.md

@@ -0,0 +1,628 @@
+# Lin - Comprehensive Setup Guide
+
+This guide provides step-by-step instructions for setting up the Lin application on different operating systems.
+
+## 📋 Table of Contents
+
+1. [Prerequisites](#prerequisites)
+2. [Quick Setup](#quick-setup)
+3. [Detailed Setup Process](#detailed-setup-process)
+4. [Environment Configuration](#environment-configuration)
+5. [Development Workflow](#development-workflow)
+6. [Troubleshooting](#troubleshooting)
+7. [Platform-Specific Instructions](#platform-specific-instructions)
+
+## 🚀 Prerequisites
+
+Before you begin, ensure you have the following installed:
+
+### System Requirements
+- **Operating System**: Windows 10/11, macOS 10.14+, or Linux (Ubuntu 18.04+)
+- **RAM**: 4GB minimum, 8GB recommended
+- **Storage**: 1GB free space
+- **Internet Connection**: Required for downloading dependencies
+
+### Software Requirements
+- **Node.js**: v16.0.0 or higher
+- **npm**: v8.0.0 or higher
+- **Python**: v3.8.0 or higher
+- **Git**: v2.0.0 or higher (for cloning the repository)
+
+### Verification Commands
+
+**Windows Command Prompt:**
+```cmd
+# Check Node.js
+node --version
+
+# Check npm
+npm --version
+
+# Check Python
+python --version
+
+# Check Git
+git --version
+```
+
+**Windows PowerShell:**
+```powershell
+# Check Node.js
+node --version
+
+# Check npm
+npm --version
+
+# Check Python
+python --version
+
+# Check Git
+git --version
+```
+
+**Linux/macOS:**
+```bash
+# Check Node.js
+node --version
+
+# Check npm
+npm --version
+
+# Check Python
+python3 --version
+
+# Check Git
+git --version
+```
+
+## 🚀 Quick Setup
+
+### Option 1: Automated Setup (Recommended)
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd Lin
+
+# Run automated setup
+npm run setup
+```
+
+### Option 2: Manual Setup
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd Lin
+
+# Install dependencies
+npm install
+
+# Setup environment files
+npm run setup:env
+
+# Build the project
+npm run build
+```
+
+## 🔧 Detailed Setup Process
+
+### Step 1: Clone the Repository
+
+```bash
+# Clone using HTTPS
+git clone https://github.com/your-username/lin.git
+
+# Or clone using SSH
+git clone git@github.com:your-username/lin.git
+
+# Navigate to the project directory
+cd lin
+```
+
+### Step 2: Install Dependencies
+
+```bash
+# Install root dependencies
+npm install
+
+# Install frontend dependencies
+npm run install:frontend
+
+# Install backend dependencies
+npm run install:backend
+```
+
+### Step 3: Configure Environment Variables
+
+#### Frontend Configuration
+
+```bash
+# Navigate to frontend directory
+cd frontend
+
+# Copy environment template
+cp .env.example .env.local
+
+# Edit the environment file
+# Open .env.local in your preferred editor
+```
+
+**Frontend Environment Variables (.env.local):**
+```env
+# API Configuration
+REACT_APP_API_URL=http://localhost:5000
+REACT_APP_ENVIRONMENT=development
+
+# Optional: Custom configuration
+REACT_APP_APP_NAME=Lin
+REACT_APP_APP_VERSION=1.0.0
+```
+
+#### Backend Configuration
+
+```bash
+# Navigate to backend directory
+cd ../backend
+
+# Copy environment template
+cp .env.example .env
+
+# Edit the environment file
+# Open .env in your preferred editor
+```
+
+**Backend Environment Variables (.env):**
+```env
+# Supabase Configuration
+SUPABASE_URL=your_supabase_project_url
+SUPABASE_KEY=your_supabase_api_key
+
+# LinkedIn OAuth Configuration
+CLIENT_ID=your_linkedin_client_id
+CLIENT_SECRET=your_linkedin_client_secret
+REDIRECT_URL=http://localhost:5000/api/auth/callback
+
+# AI/ML Configuration
+HUGGING_KEY=your_huggingface_api_key
+
+# Security Configuration
+JWT_SECRET_KEY=your_jwt_secret_key
+SECRET_KEY=your_flask_secret_key
+
+# Application Configuration
+DEBUG=True
+SCHEDULER_ENABLED=True
+PORT=5000
+```
+
+### Step 4: Build the Project
+
+```bash
+# Navigate back to root directory
+cd ..
+
+# Build frontend for production
+npm run build
+```
+
+### Step 5: Verify Installation
+
+```bash
+# Run tests
+npm test
+
+# Check linting
+npm run lint
+
+# Verify build
+npm run preview
+```
+
+## 🌐 Environment Configuration
+
+### Development Environment
+
+```bash
+# Start development servers
+npm run dev:all
+
+# Or start individually
+npm run dev:frontend  # Frontend: http://localhost:3000
+npm run dev:backend   # Backend: http://localhost:5000
+```
+
+### Production Environment
+
+```bash
+# Build for production
+npm run build:prod
+
+# Start production servers
+npm run start:prod
+```
+
+### Environment-Specific Configuration
+
+#### Development
+- Frontend runs on http://localhost:3000
+- Backend API runs on http://localhost:5000
+- Hot reload enabled
+- Debug logging enabled
+
+#### Production
+- Frontend built to static files
+- Backend runs with optimized settings
+- Debug logging disabled
+- Error handling optimized
+
+## 🛠️ Development Workflow
+
+### Daily Development
+
+1. **Start the Development Environment**
+   ```bash
+   npm run dev:all
+   ```
+
+2. **Make Changes to Code**
+   - Frontend changes are automatically hot-reloaded
+   - Backend changes require restart
+
+3. **Test Changes**
+   ```bash
+   # Run specific tests
+   npm test
+
+   # Run linting
+   npm run lint
+
+   # Fix linting issues
+   npm run lint:fix
+   ```
+
+4. **Commit Changes**
+   ```bash
+   git add .
+   git commit -m "Descriptive commit message"
+   git push
+   ```
+
+### Building for Production
+
+1. **Clean Previous Builds**
+   ```bash
+   npm run clean
+   ```
+
+2. **Build for Production**
+   ```bash
+   npm run build:prod
+   ```
+
+3. **Test Production Build**
+   ```bash
+   npm run preview
+   ```
+
+4. **Deploy**
+   ```bash
+   # Deploy to your preferred hosting platform
+   npm run deploy
+   ```
+
+### Common Development Tasks
+
+#### Adding New Dependencies
+
+```bash
+# Add frontend dependency
+cd frontend
+npm install package-name
+
+# Add backend dependency
+cd ../backend
+pip install package-name
+```
+
+#### Updating Dependencies
+
+```bash
+# Update frontend dependencies
+cd frontend
+npm update
+
+# Update backend dependencies
+cd ../backend
+pip install --upgrade package-name
+```
+
+#### Database Migrations
+
+```bash
+# Run database migrations
+cd backend
+flask db upgrade
+```
+
+## 🔍 Troubleshooting
+
+### Common Issues and Solutions
+
+#### 1. ENOENT Error: no such file or directory
+
+**Problem**: Running npm commands from the wrong directory
+**Solution**: Always run npm commands from the project root directory
+
+```bash
+# Verify you're in the correct directory
+pwd  # Linux/macOS
+cd   # Windows (shows current directory)
+
+# List files to confirm package.json exists
+ls package.json  # Linux/macOS
+dir package.json  # Windows
+```
+
+#### 2. Port Already in Use
+
+**Problem**: Port 3000 or 5000 is already occupied
+**Solution**: Find and stop the process using the port
+
+**Windows Command Prompt:**
+```cmd
+# Find process using port 3000
+netstat -ano | findstr :3000
+
+# Find process using port 5000
+netstat -ano | findstr :5000
+
+# Kill process (replace PID with actual process ID)
+taskkill /F /PID <PID>
+```
+
+**Windows PowerShell:**
+```powershell
+# Find process using port 3000
+netstat -ano | Select-String ":3000"
+
+# Find process using port 5000
+netstat -ano | Select-String ":5000"
+
+# Kill process (replace PID with actual process ID)
+Stop-Process -Id <PID> -Force
+```
+
+**Linux/macOS:**
+```bash
+# Find process using port 3000
+lsof -i :3000
+
+# Find process using port 5000
+lsof -i :5000
+
+# Kill process (replace PID with actual process ID)
+kill -9 <PID>
+```
+
+#### 3. Python/Node.js Not Recognized
+
+**Problem**: Command not found errors
+**Solution**: Add Python and Node.js to system PATH
+
+**Windows:**
+1. Press `Win + R` and type `sysdm.cpl`
+2. Go to "Advanced" tab > "Environment Variables"
+3. Under "System variables", edit "Path"
+4. Add paths to Python and Node.js installation directories
+5. Restart your terminal
+
+**Linux (Ubuntu/Debian):**
+```bash
+# Add to ~/.bashrc or ~/.zshrc
+echo 'export PATH=$PATH:/path/to/python' >> ~/.bashrc
+echo 'export PATH=$PATH:/path/to/node' >> ~/.bashrc
+source ~/.bashrc
+```
+
+**macOS:**
+```bash
+# Add to ~/.zshrc or ~/.bash_profile
+echo 'export PATH=$PATH:/path/to/python' >> ~/.zshrc
+echo 'export PATH=$PATH:/path/to/node' >> ~/.zshrc
+source ~/.zshrc
+```
+
+#### 4. Permission Denied Errors
+
+**Problem**: Permission issues when installing dependencies
+**Solution**: Run with proper permissions or use package managers
+
+**Windows:**
+```cmd
+# Run as Administrator
+# Or check file permissions
+```
+
+**Linux/macOS:**
+```bash
+# Fix permissions
+chmod -R 755 node_modules
+chmod -R 755 backend/venv
+```
+
+#### 5. Environment Variable Issues
+
+**Problem**: Environment variables not loading
+**Solution**: Verify file paths and permissions
+
+**Windows Command Prompt:**
+```cmd
+# Check if environment files exist
+if exist frontend\.env.local (
+    echo Frontend environment file exists
+) else (
+    echo Frontend environment file missing
+)
+
+if exist backend\.env (
+    echo Backend environment file exists
+) else (
+    echo Backend environment file missing
+)
+```
+
+**Windows PowerShell:**
+```powershell
+# Check if environment files exist
+if (Test-Path frontend\.env.local) {
+    Write-Host "Frontend environment file exists" -ForegroundColor Green
+} else {
+    Write-Host "Frontend environment file missing" -ForegroundColor Red
+}
+
+if (Test-Path backend\.env) {
+    Write-Host "Backend environment file exists" -ForegroundColor Green
+} else {
+    Write-Host "Backend environment file missing" -ForegroundColor Red
+}
+```
+
+## 🖥️ Platform-Specific Instructions
+
+### Windows Setup
+
+#### Prerequisites Installation
+1. **Download Node.js**: Visit https://nodejs.org and download the LTS version
+2. **Download Python**: Visit https://python.org and download Python 3.8+
+3. **Install Git**: Download from https://git-scm.com
+
+#### Environment Setup
+```cmd
+# Command Prompt setup
+copy frontend\.env.example frontend\.env.local
+copy backend\.env.example backend\.env
+
+# PowerShell setup
+Copy-Item frontend\.env.example -Destination frontend\.env.local
+Copy-Item backend\.env.example -Destination backend\.env
+```
+
+#### Development Commands
+```cmd
+# Install dependencies
+npm install
+npm run install:all:win
+
+# Start development
+npm run dev:all
+
+# Build project
+npm run build
+```
+
+### macOS Setup
+
+#### Prerequisites Installation
+```bash
+# Install using Homebrew
+brew install node
+brew install python
+brew install git
+
+# Or download from official websites
+```
+
+#### Environment Setup
+```bash
+# Copy environment files
+cp frontend/.env.example frontend/.env.local
+cp backend/.env.example backend/.env
+
+# Set permissions
+chmod 600 frontend/.env.local
+chmod 600 backend/.env
+```
+
+#### Development Commands
+```bash
+# Install dependencies
+npm install
+npm run install:all
+
+# Start development
+npm run dev:all
+
+# Build project
+npm run build
+```
+
+### Linux Setup
+
+#### Prerequisites Installation
+```bash
+# Ubuntu/Debian
+sudo apt update
+sudo apt install nodejs npm python3 python3-pip git
+
+# CentOS/RHEL
+sudo yum install nodejs npm python3 python3-pip git
+
+# Arch Linux
+sudo pacman -S nodejs npm python python-pip git
+```
+
+#### Environment Setup
+```bash
+# Copy environment files
+cp frontend/.env.example frontend/.env.local
+cp backend/.env.example backend/.env
+
+# Set permissions
+chmod 600 frontend/.env.local
+chmod 600 backend/.env
+```
+
+#### Development Commands
+```bash
+# Install dependencies
+npm install
+npm run install:all
+
+# Start development
+npm run dev:all
+
+# Build project
+npm run build
+```
+
+## 📚 Additional Resources
+
+- [API Documentation](./backend/README.md)
+- [Frontend Development Guide](./frontend/README.md)
+- [Windows Compatibility Guide](./test_windows_compatibility.md)
+- [Troubleshooting Guide](./TROUBLESHOOTING.md)
+- [Contributing Guidelines](./CONTRIBUTING.md)
+
+## 🆘 Getting Help
+
+If you encounter issues not covered in this guide:
+
+1. Check the [Troubleshooting Guide](./TROUBLESHOOTING.md)
+2. Search existing [GitHub Issues](https://github.com/your-username/lin/issues)
+3. Create a new issue with:
+   - Operating system and version
+   - Node.js and Python versions
+   - Error messages and stack traces
+   - Steps to reproduce the issue
+
+## 🎯 Next Steps
+
+After completing the setup:
+
+1. **Explore the Application**: Navigate to http://localhost:3000
+2. **Read the Documentation**: Check the API documentation and user guides
+3. **Join the Community**: Join our Discord server or mailing list
+4. **Start Contributing**: Check out the contributing guidelines
+
+Happy coding! 🚀

UI_COMPONENT_SNAPSHOT.md

@@ -0,0 +1,208 @@
+# Lin UI Component Snapshot
+
+## Overview
+
+This document provides a snapshot of the current UI components in the Lin application, focusing on recent changes to the Header and Sidebar components.
+
+## Recent UI Changes
+
+### Header Component Updates
+
+The Header component has been modified to improve the user interface:
+
+1. **Moved User Profile and Logout**:
+   - Relocated the user profile and logout functionality to the far right of the header
+   - This change provides a more intuitive user experience by placing account-related actions in the top-right corner
+
+2. **Removed Desktop Navigation Items**:
+   - Cleared the desktop navigation area (previously in the center) to create a cleaner interface
+   - This change focuses attention on the primary content and reduces visual clutter
+
+### Sidebar Component Updates
+
+The Sidebar component has been modified to improve the user interface:
+
+1. **Removed Username Display**:
+   - Removed the username display from the bottom of the sidebar
+   - This change creates a cleaner sidebar interface and reduces information overload
+
+## Current UI Component Structure
+
+### Header Component
+
+Location: `frontend/src/components/Header/Header.jsx`
+
+Key Features:
+- Fixed position at the top of the screen
+- Responsive design for mobile and desktop
+- Mobile menu toggle button
+- User profile and logout functionality (top-right)
+- Logo and application title (top-left)
+- Backdrop blur effect for modern appearance
+
+### Sidebar Component
+
+Location: `frontend/src/components/Sidebar/Sidebar.jsx`
+
+Key Features:
+- Collapsible design with smooth animations
+- Responsive behavior for mobile and desktop
+- Navigation menu with icons and labels
+- Gradient backgrounds and modern styling
+- Touch-optimized for mobile devices
+- Keyboard navigation support
+
+### App Layout
+
+Location: `frontend/src/App.jsx`
+
+Key Features:
+- Conditional rendering based on authentication state
+- Responsive layout with Header and Sidebar
+- Mobile-first design approach
+- Accessibility features (skip links, ARIA attributes)
+- Performance optimizations (lazy loading, memoization)
+
+## Component Interactions
+
+### Authentication State Handling
+
+The UI components adapt based on the user's authentication state:
+
+1. **Unauthenticated Users**:
+   - See only the logo and application title in the header
+   - No sidebar is displayed
+   - Redirected to login/register pages
+
+2. **Authenticated Users**:
+   - See user profile and logout options in the header
+   - Have access to the full sidebar navigation
+   - Can access protected routes (dashboard, sources, posts, etc.)
+
+### Responsive Behavior
+
+1. **Desktop (>1024px)**:
+   - Full sidebar is visible by default
+   - Header displays user profile information
+   - Traditional navigation patterns
+
+2. **Mobile/Tablet (<1024px)**:
+   - Sidebar is collapsed by default
+   - Header includes mobile menu toggle
+   - Touch-optimized interactions
+   - Overlay effects for mobile menus
+
+## Styling and Design System
+
+### Color Palette
+
+The application uses a consistent color palette:
+
+- Primary: Burgundy (#910029)
+- Secondary: Dark Gray (#39404B)
+- Accent: Light Blue (#ECF4F7)
+- Background: Light gradient backgrounds
+- Text: Dark Blue-Gray (#2c3e50)
+
+### Typography
+
+- Font family: System UI fonts
+- Font weights: 400 (regular), 500 (medium), 600 (semi-bold), 700 (bold)
+- Responsive font sizes using Tailwind's scale
+
+### Spacing System
+
+- Consistent spacing using Tailwind's spacing scale
+- Responsive padding and margin adjustments
+- Grid-based layout system
+
+## Performance Considerations
+
+### Optimizations Implemented
+
+1. **Lazy Loading**:
+   - Components loaded on-demand
+   - Code splitting for better initial load times
+
+2. **Memoization**:
+   - React.memo for components
+   - useMemo and useCallback for expensive operations
+
+3. **Skeleton Loading**:
+   - Loading states for data fetching
+   - Smooth transitions between loading and content states
+
+### Mobile Performance
+
+1. **Touch Optimization**:
+   - Touch-manipulation classes for better mobile interactions
+   - Hardware acceleration for animations
+
+2. **Reduced Complexity**:
+   - Simplified animations on mobile devices
+   - Optimized rendering for smaller screens
+
+## Accessibility Features
+
+### Implemented Features
+
+1. **Keyboard Navigation**:
+   - Arrow key navigation for menus
+   - Escape key to close modals/menus
+   - Skip links for screen readers
+
+2. **ARIA Attributes**:
+   - Proper labeling of interactive elements
+   - Role attributes for semantic structure
+   - Live regions for dynamic content
+
+3. **Focus Management**:
+   - Visible focus indicators
+   - Proper focus trapping for modals
+   - Focus restoration after interactions
+
+## Testing and Quality Assurance
+
+### Component Testing
+
+1. **Unit Tests**:
+   - Component rendering tests
+   - Prop validation
+   - Event handling verification
+
+2. **Integration Tests**:
+   - State management verification
+   - API integration testing
+   - Routing behavior validation
+
+### Browser Compatibility
+
+1. **Supported Browsers**:
+   - Latest Chrome, Firefox, Safari, Edge
+   - Mobile browsers (iOS Safari, Chrome for Android)
+
+2. **Responsive Testing**:
+   - Multiple screen sizes
+   - Orientation changes
+   - Touch vs. mouse interactions
+
+## Future Improvements
+
+### Planned Enhancements
+
+1. **UI/UX Improvements**:
+   - Enhanced animations and transitions
+   - Improved loading states
+   - Additional accessibility features
+
+2. **Performance Optimizations**:
+   - Further code splitting
+   - Image optimization
+   - Caching strategies
+
+3. **Feature Additions**:
+   - Dark mode support
+   - Customizable layouts
+   - Advanced analytics dashboard
+
+This snapshot represents the current state of the UI components as of the recent changes. The modifications to the Header and Sidebar have created a cleaner, more intuitive interface while maintaining all core functionality.

api_design.md

@@ -0,0 +1,348 @@
+# API Design Document
+
+## Overview
+This document outlines the RESTful API endpoints for the Lin application backend. The API will be implemented using Flask and will follow REST conventions.
+
+## Authentication
+All endpoints (except authentication endpoints) require a valid JWT token in the Authorization header:
+```
+Authorization: Bearer <token>
+```
+
+## Error Handling
+All endpoints will return appropriate HTTP status codes:
+- 200: Success
+- 201: Created
+- 400: Bad Request
+- 401: Unauthorized
+- 404: Not Found
+- 500: Internal Server Error
+
+Error responses will follow this format:
+```json
+{
+  "error": "Error message",
+  "code": "ERROR_CODE"
+}
+```
+
+## Endpoints
+
+### Authentication
+
+#### Register User
+- **POST** `/api/auth/register`
+- **Description**: Register a new user
+- **Request Body**:
+```json
+{
+  "email": "string",
+  "password": "string",
+  "confirm_password": "string"
+}
+```
+- **Response**:
+```json
+{
+  "message": "User registered successfully",
+  "user": {
+    "id": "string",
+    "email": "string"
+  }
+}
+```
+
+#### Login User
+- **POST** `/api/auth/login`
+- **Description**: Authenticate a user
+- **Request Body**:
+```json
+{
+  "email": "string",
+  "password": "string"
+}
+```
+- **Response**:
+```json
+{
+  "token": "string",
+  "user": {
+    "id": "string",
+    "email": "string"
+  }
+}
+```
+
+#### Logout User
+- **POST** `/api/auth/logout`
+- **Description**: Logout current user
+- **Response**:
+```json
+{
+  "message": "Logged out successfully"
+}
+```
+
+#### Get Current User
+- **GET** `/api/auth/user`
+- **Description**: Get current authenticated user
+- **Response**:
+```json
+{
+  "user": {
+    "id": "string",
+    "email": "string"
+  }
+}
+```
+
+### Sources
+
+#### Get All Sources
+- **GET** `/api/sources`
+- **Description**: Get all sources for the current user
+- **Response**:
+```json
+{
+  "sources": [
+    {
+      "id": "string",
+      "user_id": "string",
+      "source": "string",
+      "category": "string",
+      "last_update": "datetime"
+    }
+  ]
+}
+```
+
+#### Add Source
+- **POST** `/api/sources`
+- **Description**: Add a new source
+- **Request Body**:
+```json
+{
+  "source": "string"
+}
+```
+- **Response**:
+```json
+{
+  "message": "Source added successfully",
+  "source": {
+    "id": "string",
+    "user_id": "string",
+    "source": "string",
+    "category": "string",
+    "last_update": "datetime"
+  }
+}
+```
+
+#### Delete Source
+- **DELETE** `/api/sources/{id}`
+- **Description**: Delete a source
+- **Response**:
+```json
+{
+  "message": "Source deleted successfully"
+}
+```
+
+### Social Accounts
+
+#### Get All Accounts
+- **GET** `/api/accounts`
+- **Description**: Get all social media accounts for the current user
+- **Response**:
+```json
+{
+  "accounts": [
+    {
+      "id": "string",
+      "user_id": "string",
+      "social_network": "string",
+      "account_name": "string",
+      "created_at": "datetime"
+    }
+  ]
+}
+```
+
+#### Add Account
+- **POST** `/api/accounts`
+- **Description**: Add a new social media account
+- **Request Body**:
+```json
+{
+  "account_name": "string",
+  "social_network": "string"
+}
+```
+- **Response**:
+```json
+{
+  "message": "Account added successfully",
+  "account": {
+    "id": "string",
+    "user_id": "string",
+    "social_network": "string",
+    "account_name": "string",
+    "created_at": "datetime"
+  }
+}
+```
+
+#### Delete Account
+- **DELETE** `/api/accounts/{id}`
+- **Description**: Delete a social media account
+- **Response**:
+```json
+{
+  "message": "Account deleted successfully"
+}
+```
+
+### Posts
+
+#### Get All Posts
+- **GET** `/api/posts`
+- **Description**: Get all posts for the current user
+- **Query Parameters**:
+  - `published` (boolean): Filter by published status
+- **Response**:
+```json
+{
+  "posts": [
+    {
+      "id": "string",
+      "user_id": "string",
+      "social_account_id": "string",
+      "text_content": "string",
+      "image_content_url": "string",
+      "is_published": "boolean",
+      "created_at": "datetime",
+      "scheduled_at": "datetime"
+    }
+  ]
+}
+```
+
+#### Generate Post
+- **POST** `/api/posts/generate`
+- **Description**: Generate a new post using AI
+- **Request Body**:
+```json
+{
+  "user_id": "string"
+}
+```
+- **Response**:
+```json
+{
+  "content": "string"
+}
+```
+
+#### Create Post
+- **POST** `/api/posts`
+- **Description**: Create a new post
+- **Request Body**:
+```json
+{
+  "social_account_id": "string",
+  "text_content": "string",
+  "image_content_url": "string",
+  "scheduled_at": "datetime"
+}
+```
+- **Response**:
+```json
+{
+  "message": "Post created successfully",
+  "post": {
+    "id": "string",
+    "user_id": "string",
+    "social_account_id": "string",
+    "text_content": "string",
+    "image_content_url": "string",
+    "is_published": "boolean",
+    "created_at": "datetime",
+    "scheduled_at": "datetime"
+  }
+}
+```
+
+#### Publish Post
+- **POST** `/api/posts/{id}/publish`
+- **Description**: Publish a post to social media
+- **Response**:
+```json
+{
+  "message": "Post published successfully"
+}
+```
+
+#### Delete Post
+- **DELETE** `/api/posts/{id}`
+- **Description**: Delete a post
+- **Response**:
+```json
+{
+  "message": "Post deleted successfully"
+}
+```
+
+### Schedules
+
+#### Get All Schedules
+- **GET** `/api/schedules`
+- **Description**: Get all schedules for the current user
+- **Response**:
+```json
+{
+  "schedules": [
+    {
+      "id": "string",
+      "social_account_id": "string",
+      "schedule_time": "string",
+      "adjusted_time": "string",
+      "created_at": "datetime"
+    }
+  ]
+}
+```
+
+#### Create Schedule
+- **POST** `/api/schedules`
+- **Description**: Create a new schedule
+- **Request Body**:
+```json
+{
+  "social_account_id": "string",
+  "schedule_time": "string",  // Format: "Monday 18:00"
+  "days": ["string"]          // Array of days
+}
+```
+- **Response**:
+```json
+{
+  "message": "Schedule created successfully",
+  "schedule": {
+    "id": "string",
+    "social_account_id": "string",
+    "schedule_time": "string",
+    "adjusted_time": "string",
+    "created_at": "datetime"
+  }
+}
+```
+
+#### Delete Schedule
+- **DELETE** `/api/schedules/{id}`
+- **Description**: Delete a schedule
+- **Response**:
+```json
+{
+  "message": "Schedule deleted successfully"
+}

app.py

@@ -0,0 +1,26 @@
+"""
+Entry point for the Lin application on Hugging Face Spaces.
+This file imports and runs the backend Flask application directly.
+"""
+import os
+import sys
+
+if __name__ == '__main__':
+    # Set the port for Hugging Face Spaces
+    port = os.environ.get('PORT', '7860')
+    os.environ.setdefault('PORT', port)
+    
+    print(f"Starting Lin application on port {port}...")
+    
+    try:
+        # Import and run the backend Flask app directly
+        from backend.app import create_app
+        app = create_app()
+        app.run(
+            host='0.0.0.0',
+            port=int(port),
+            debug=False
+        )
+    except Exception as e:
+        print(f"Failed to start Lin application: {e}")
+        sys.exit(1)

architecture_summary.md

@@ -0,0 +1,111 @@
+# Lin React Clone - Architecture Summary
+
+## Project Overview
+This document provides a comprehensive summary of the architecture for the React clone of the Lin application, which includes a Flask API backend and a React frontend.
+
+## Current Status
+The current Taipy-based Lin application has been thoroughly analyzed, and a complete architecture plan has been created for the React clone with the following components:
+
+### Documentation Created
+1. [Project Analysis](project_analysis.md) - Analysis of the current Taipy application
+2. [README](README.md) - Overview of the React clone project
+3. [Backend Structure](backend_structure.md) - Planned structure for the Flask API backend
+4. [Frontend Structure](frontend_structure.md) - Planned structure for the React frontend
+5. [API Design](api_design.md) - Detailed RESTful API endpoints
+6. [Component Architecture](component_architecture.md) - React component hierarchy and design
+7. [Backend Requirements](backend_requirements.md) - Technical requirements for the Flask backend
+8. [Frontend Requirements](frontend_requirements.md) - Technical requirements for the React frontend
+9. [Deployment Architecture](deployment_architecture.md) - Infrastructure and deployment plan
+10. [Development Roadmap](development_roadmap.md) - Phased implementation plan
+
+## Key Architectural Decisions
+
+### Backend Architecture
+- **Framework**: Flask for lightweight, flexible API development
+- **Database**: Supabase (PostgreSQL-based) for data persistence
+- **Authentication**: JWT-based authentication with secure token management
+- **Scheduling**: APScheduler for task scheduling with conflict resolution
+- **External Integrations**: LinkedIn API and Hugging Face API
+- **Deployment**: Containerized deployment with horizontal scaling
+
+### Frontend Architecture
+- **Framework**: React with functional components and hooks
+- **State Management**: Redux Toolkit for predictable state management
+- **Routing**: React Router for client-side routing
+- **UI Components**: Material-UI for consistent, accessible components
+- **Form Handling**: Formik with Yup for form validation
+- **API Communication**: Axios with interceptors for HTTP requests
+- **Deployment**: Static hosting with CDN for optimal performance
+
+### Data Flow
+1. User interacts with React frontend
+2. Frontend makes API calls to Flask backend
+3. Backend processes requests and interacts with Supabase database
+4. Backend integrates with external APIs (LinkedIn, Hugging Face)
+5. Backend returns data to frontend
+6. Frontend updates UI based on response
+
+### Security Considerations
+- JWT tokens for secure authentication
+- HTTPS encryption for all communications
+- Input validation and sanitization
+- CORS policy configuration
+- Secure storage of sensitive data
+- Rate limiting for API endpoints
+
+## Implementation Roadmap
+
+The development is planned in 6 phases over 12 weeks:
+
+1. **Foundation** (Weeks 1-2): Project setup, authentication
+2. **Core Features** (Weeks 3-4): Source and account management
+3. **Content Management** (Weeks 5-6): Post creation and publishing
+4. **Scheduling System** (Weeks 7-8): Automated scheduling
+5. **Advanced Features** (Weeks 9-10): Analytics and optimization
+6. **Testing and Deployment** (Weeks 11-12): Production readiness
+
+## Technology Stack
+
+### Backend
+- Flask (Python web framework)
+- Supabase (Database and authentication)
+- APScheduler (Task scheduling)
+- requests (HTTP library)
+- python-dotenv (Environment management)
+
+### Frontend
+- React (JavaScript library)
+- Redux Toolkit (State management)
+- Material-UI (UI components)
+- React Router (Routing)
+- Axios (HTTP client)
+- Formik/Yup (Form handling)
+
+## Deployment Architecture
+
+The application will be deployed with:
+- CDN for frontend assets
+- Load balancer for backend API
+- Containerized Flask applications
+- Supabase for database and authentication
+- Monitoring and logging infrastructure
+- CI/CD pipeline for automated deployment
+
+## Next Steps
+
+To begin implementation, the following actions are recommended:
+
+1. Set up development environments for both frontend and backend
+2. Create GitHub repositories for version control
+3. Implement the foundation phase (authentication, project structure)
+4. Begin CI/CD pipeline setup
+5. Start frontend and backend development in parallel
+
+## Success Criteria
+
+The success of this architecture will be measured by:
+- Performance (API response times < 500ms)
+- Reliability (99.9% uptime)
+- Scalability (support for 10,000+ users)
+- User satisfaction (intuitive UI/UX)
+- Maintainability (modular, well-documented code)

backend/.env.example

@@ -0,0 +1,27 @@
+# Supabase configuration
+SUPABASE_URL="https://xscdoxrxtnibshcfznuy.supabase.co"
+SUPABASE_KEY="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InhzY2RveHJ4dG5pYnNoY2Z6bnV5Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTAyNDk1MzMsImV4cCI6MjA2NTgyNTUzM30.C7EF6VwL44O0yS2Xi5dLz_iNSk6s-8cO1fQq7aab8NA"
+
+# LinkedIn OAuth configuration
+CLIENT_ID="786uz2fclmtgnd"
+CLIENT_SECRET="WPL_AP1.L2w25M5xMwPb6vR3.75REhw=="
+REDIRECT_URL=https://zelyanoth-lin.hf.space/auth/callback
+
+# Hugging Face configuration
+
+
+# JWT configuration
+JWT_SECRET_KEY=your_jwt_secret_key
+
+# Database configuration (if using direct database connection)
+DATABASE_URL=your_database_url
+
+# Application configuration
+SECRET_KEY=your_secret_key
+DEBUG=True
+
+# Scheduler configuration
+SCHEDULER_ENABLED=True
+
+# Port configuration
+PORT=5000

backend/Dockerfile

@@ -0,0 +1,40 @@
+# Use Python 3.9 slim image
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set environment variables for UTF-8 encoding
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+ENV LANG=C.UTF-8
+ENV LC_ALL=C.UTF-8
+ENV PYTHONIOENCODING=utf-8
+ENV PYTHONUTF8=1
+ENV DOCKER_CONTAINER=true
+
+# Install system dependencies
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY . .
+
+# Create non-root user
+RUN adduser --disabled-password --gecos '' appuser
+RUN chown -R appuser:appuser /app
+USER appuser
+
+# Expose port
+EXPOSE 5000
+
+# Run the application
+CMD ["python", "app.py"]

backend/README.md

@@ -0,0 +1,275 @@
+# Lin Backend API
+
+This is the Flask backend API for the Lin application, a community manager assistant for LinkedIn.
+
+## Features
+
+- User authentication (registration, login, logout)
+- Social media account management (LinkedIn integration)
+- RSS source management
+- AI-powered content generation
+- Post scheduling and publishing
+- RESTful API design
+- JWT-based authentication
+- Task scheduling with Celery
+
+## Technologies
+
+- Flask (Python web framework)
+- Supabase (Database and authentication)
+- Celery (Distributed task queue)
+- Redis (Message broker for Celery)
+- requests (HTTP library)
+- requests-oauthlib (OAuth support)
+- gradio-client (Hugging Face API)
+- Flask-JWT-Extended (JWT token management)
+
+## Project Structure
+
+```
+backend/
+├── app.py                 # Flask application entry point
+├── config.py              # Configuration settings
+├── requirements.txt       # Python dependencies
+├── .env.example          # Environment variables example
+├── celery_app.py          # Celery application configuration
+├── celery_beat_config.py  # Celery Beat configuration
+├── start_celery.sh        # Script to start Celery components (Linux/Mac)
+├── start_celery.bat       # Script to start Celery components (Windows)
+├── TASK_SCHEDULING_EVOLUTION.md # Documentation on migration from APScheduler to Celery
+├── models/                # Data models
+│   ├── __init__.py
+│   ├── user.py            # User model
+│   ├── social_account.py  # Social media account model
+│   ├── source.py          # RSS source model
+│   ├── post.py            # Post content model
+│   └── schedule.py        # Scheduling model
+├── api/                   # API endpoints
+│   ├── __init__.py
+│   ├── auth.py            # Authentication endpoints
+│   ├── sources.py         # Source management endpoints
+│   ├── accounts.py        # Social account endpoints
+│   ├── posts.py           # Post management endpoints
+│   └── schedules.py       # Scheduling endpoints
+├── services/              # Business logic
+│   ├── __init__.py
+│   ├── auth_service.py    # Authentication service
+│   ├── linkedin_service.py# LinkedIn integration service
+│   ├── content_service.py # Content generation service
+│   └── schedule_service.py# Scheduling service
+├── celery_tasks/          # Celery tasks
+│   ├── __init__.py
+│   ├── content_tasks.py   # Content generation and publishing tasks
+│   ├── scheduler.py       # Scheduler functions
+│   └── schedule_loader.py # Task for loading schedules from database
+├── utils/                 # Utility functions
+│   ├── __init__.py
+│   └── database.py        # Database connection
+└── scheduler/             # Task scheduling (deprecated, kept for backward compatibility)
+    ├── __init__.py
+    └── task_scheduler.py  # Scheduling implementation
+```
+
+## API Endpoints
+
+### Authentication
+- `POST /api/auth/register` - Register a new user
+- `POST /api/auth/login` - Login user
+- `POST /api/auth/logout` - Logout user
+- `GET /api/auth/user` - Get current user
+
+### Sources
+- `GET /api/sources` - Get all sources for current user
+- `POST /api/sources` - Add a new source
+- `DELETE /api/sources/<id>` - Delete a source
+
+### Accounts
+- `GET /api/accounts` - Get all social accounts for current user
+- `POST /api/accounts` - Add a new social account
+- `POST /api/accounts/callback` - Handle OAuth callback
+- `DELETE /api/accounts/<id>` - Delete a social account
+
+### Posts
+- `GET /api/posts` - Get all posts for current user
+- `POST /api/posts/generate` - Generate AI content
+- `POST /api/posts` - Create a new post
+- `POST /api/posts/<id>/publish` - Publish a post
+- `DELETE /api/posts/<id>` - Delete a post
+
+### Schedules
+- `GET /api/schedules` - Get all schedules for current user
+- `POST /api/schedules` - Create a new schedule
+- `DELETE /api/schedules/<id>` - Delete a schedule
+
+## Setup Instructions
+
+1. **Install dependencies**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **Set up environment variables**:
+   Copy `.env.example` to `.env` and fill in your values:
+   ```bash
+   # Windows Command Prompt
+   copy .env.example .env
+   
+   # PowerShell
+   Copy-Item .env.example .env
+   ```
+
+3. **Start Redis Server**:
+   ```bash
+   # If you have Redis installed locally
+   redis-server
+   
+   # Or use Docker
+   docker run -d -p 6379:6379 redis:alpine
+   ```
+
+4. **Start Celery Components**:
+   ```bash
+   # Start Celery worker
+   celery -A celery_app worker --loglevel=info
+   
+   # Start Celery Beat scheduler (in another terminal)
+   celery -A celery_beat_config beat --loglevel=info
+   ```
+
+5. **Run the application**:
+   ```bash
+   python app.py
+   ```
+
+## Environment Variables
+
+- `SUPABASE_URL` - Your Supabase project URL
+- `SUPABASE_KEY` - Your Supabase API key
+- `CLIENT_ID` - LinkedIn OAuth client ID
+- `CLIENT_SECRET` - LinkedIn OAuth client secret
+- `REDIRECT_URL` - LinkedIn OAuth redirect URL
+- `HUGGING_KEY` - Hugging Face API key
+- `JWT_SECRET_KEY` - Secret key for JWT token generation
+- `SECRET_KEY` - Flask secret key
+- `DEBUG` - Debug mode (True/False)
+- `SCHEDULER_ENABLED` - Enable/disable task scheduler (True/False)
+- `PORT` - Port to run the application on
+- `CELERY_BROKER_URL` - Redis URL for Celery broker (default: redis://localhost:6379/0)
+- `CELERY_RESULT_BACKEND` - Redis URL for Celery result backend (default: redis://localhost:6379/0)
+
+## Development
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Linting
+
+```bash
+flake8 .
+```
+
+### Starting Celery Components with Scripts
+
+On Linux/Mac:
+```bash
+# Start both worker and scheduler
+./start_celery.sh all
+
+# Start only worker
+./start_celery.sh worker
+
+# Start only scheduler
+./start_celery.sh beat
+```
+
+On Windows:
+```cmd
+# Start both worker and scheduler
+start_celery.bat all
+
+# Start only worker
+start_celery.bat worker
+
+# Start only scheduler
+start_celery.bat beat
+```
+
+### Windows-Specific Issues
+
+1. **File Copy Commands**
+   - Use `copy` command in Command Prompt or `Copy-Item` in PowerShell
+   - Avoid using Unix-style `cp` command which doesn't work on Windows
+
+2. **Python Installation Issues**
+   - Ensure Python is added to your system PATH
+   - Try using `python` instead of `python3` if you have Python 3.x installed
+   - If `pip` fails, try `python -m pip install -r requirements.txt`
+
+3. **Permission Issues**
+   - If you encounter permission errors, try running your terminal as Administrator
+   - Or check file permissions on the project directory
+
+4. **Port Conflicts**
+   - Windows might have other services using port 5000
+   - Use `netstat -ano | findstr :5000` to check what's using port 5000
+   - Change port in configuration if needed
+
+5. **Virtual Environment Issues**
+   - If using virtual environments, ensure they're activated properly
+   - On Windows, use `venv\Scripts\activate` for Command Prompt
+   - Or `venv\Scripts\Activate.ps1` for PowerShell
+
+6. **Environment Variables**
+   - Use `set` command in Command Prompt to set environment variables
+   - Use `$env:VARIABLE_NAME="value"` in PowerShell
+   - Or use the Windows GUI (System Properties > Environment Variables)
+
+## Deployment
+
+The application can be deployed to any platform that supports Python applications:
+
+1. **Heroku**:
+   - Create a new Heroku app
+   - Set environment variables in Heroku config
+   - Deploy using Git
+   - Add Redis add-on for Celery
+
+2. **Docker**:
+   ```bash
+   # The docker-compose.yml file includes Redis
+   docker-compose up
+   ```
+
+3. **Traditional Server**:
+   - Install Python dependencies
+   - Set environment variables
+   - Install and start Redis
+   - Start Celery components
+   - Run with a WSGI server like Gunicorn
+
+## Task Scheduling with Celery
+
+The application now uses Celery for task scheduling instead of APScheduler. This provides better scalability and reliability:
+
+1. **Content Generation Tasks**: Generate AI content for scheduled posts
+2. **Post Publishing Tasks**: Publish posts to LinkedIn
+3. **Schedule Loader Task**: Periodically loads schedules from the database
+
+Tasks are stored in Redis and can be processed by multiple workers, making the system more robust and scalable.
+
+For more details on the migration from APScheduler to Celery, see `TASK_SCHEDULING_EVOLUTION.md`.
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a pull request
+
+## License
+
+This project is licensed under the MIT License.

backend/TASK_SCHEDULING_EVOLUTION.md

@@ -0,0 +1,124 @@
+# Task Scheduling Evolution: From APScheduler to Celery
+
+## Overview
+
+This document describes the evolution of the task scheduling system in the Lin application from using APScheduler to using Celery. This change was made to improve scalability, reliability, and maintainability of the scheduling system.
+
+## Previous Implementation (APScheduler)
+
+The previous implementation used APScheduler (Advanced Python Scheduler) for managing scheduled tasks. While APScheduler is a powerful library, it has some limitations in production environments:
+
+1. **Single Process**: APScheduler runs within the same process as the Flask application, which can lead to resource contention.
+2. **Limited Scalability**: Difficult to scale across multiple instances or servers.
+3. **Persistence Issues**: While APScheduler supports job persistence, it's not as robust as dedicated task queues.
+4. **Monitoring**: Limited built-in monitoring and management capabilities.
+
+### Key Components of APScheduler Implementation:
+
+- `backend/scheduler/task_scheduler.py`: Main scheduler implementation
+- `backend/app.py`: Scheduler initialization in Flask app
+- Jobs were stored in memory and periodically reloaded from the database
+
+## New Implementation (Celery)
+
+The new implementation uses Celery, a distributed task queue, which provides several advantages:
+
+1. **Distributed Processing**: Tasks can be distributed across multiple workers and machines.
+2. **Persistence**: Tasks are stored in a message broker (Redis) for reliability.
+3. **Scalability**: Easy to scale by adding more workers.
+4. **Monitoring**: Built-in monitoring tools and integration with Flower for web-based monitoring.
+5. **Fault Tolerance**: Workers can be restarted without losing tasks.
+6. **Flexible Routing**: Tasks can be routed to specific queues for better resource management.
+
+### Key Components of Celery Implementation:
+
+- `backend/celery_app.py`: Main Celery application configuration
+- `backend/celery_tasks/`: Directory containing Celery tasks
+  - `content_tasks.py`: Tasks for content generation and publishing
+  - `scheduler.py`: Scheduler functions for task management
+  - `schedule_loader.py`: Task for loading schedules from database
+- `backend/celery_beat_config.py`: Celery Beat configuration for periodic tasks
+- `backend/scheduler/task_scheduler.py`: Updated scheduler that works with Celery
+
+### Celery Architecture
+
+The new implementation follows this architecture:
+
+```
+[Flask App] --> [Redis Broker] --> [Celery Workers]
+                     ^
+                     |
+               [Celery Beat]
+```
+
+1. **Flask App**: The main web application that can trigger tasks
+2. **Redis Broker**: Message broker that stores tasks and results
+3. **Celery Workers**: Processes that execute tasks
+4. **Celery Beat**: Scheduler that triggers periodic tasks
+
+### Task Types
+
+1. **Content Generation Task**: Generates content for scheduled posts
+2. **Post Publishing Task**: Publishes posts to LinkedIn
+3. **Schedule Loader Task**: Periodically loads schedules from the database and updates Celery Beat
+
+### Configuration
+
+The Celery implementation is configured through environment variables:
+
+- `CELERY_BROKER_URL`: URL for the message broker (default: redis://localhost:6379/0)
+- `CELERY_RESULT_BACKEND`: URL for the result backend (default: redis://localhost:6379/0)
+
+### Running the System
+
+To run the new Celery-based system:
+
+1. **Start Redis Server**:
+   ```bash
+   redis-server
+   ```
+
+2. **Start Celery Workers**:
+   ```bash
+   cd backend
+   celery -A celery_app worker --loglevel=info
+   ```
+
+3. **Start Celery Beat (Scheduler)**:
+   ```bash
+   cd backend
+   celery -A celery_beat_config beat --loglevel=info
+   ```
+
+4. **Start Flask Application**:
+   ```bash
+   cd backend
+   python app.py
+   ```
+
+### Benefits of the Migration
+
+1. **Improved Reliability**: Tasks are persisted in Redis and survive worker restarts
+2. **Better Scalability**: Can easily add more workers to handle increased load
+3. **Enhanced Monitoring**: Can use Flower to monitor tasks and workers
+4. **Separation of Concerns**: Web application and task processing are now separate processes
+5. **Fault Tolerance**: If one worker fails, others can continue processing tasks
+6. **Flexible Deployment**: Workers can be deployed on different machines
+
+### Migration Process
+
+The migration was done in a way that maintains backward compatibility:
+
+1. **New Components Added**: All Celery components were added without removing the old ones
+2. **Configuration Update**: The Flask app was updated to use Celery instead of APScheduler
+3. **Task Refactoring**: Existing task logic was refactored into Celery tasks
+4. **Testing**: The new system was tested to ensure it works correctly
+5. **Documentation**: This document was created to explain the changes
+
+### Future Improvements
+
+1. **Add Flower for Monitoring**: Integrate Flower for web-based task monitoring
+2. **Implement Retry Logic**: Add more sophisticated retry logic for failed tasks
+3. **Add Task Priorities**: Implement task priorities for better resource management
+4. **Enhance Error Handling**: Improve error handling and logging for tasks
+5. **Add Task Chaining**: Use Celery's chaining capabilities for complex workflows

backend/api/accounts.py

@@ -0,0 +1,311 @@
+from flask import Blueprint, request, jsonify, current_app
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from services.linkedin_service import LinkedInService
+import secrets
+
+accounts_bp = Blueprint('accounts', __name__)
+
+@accounts_bp.route('/', methods=['OPTIONS'])
+@accounts_bp.route('', methods=['OPTIONS'])
+def handle_options():
+    """Handle OPTIONS requests for preflight CORS checks."""
+    return '', 200
+
+@accounts_bp.route('/', methods=['GET'])
+@accounts_bp.route('', methods=['GET'])
+@jwt_required()
+def get_accounts():
+    """
+    Get all social media accounts for the current user.
+    
+    Returns:
+        JSON: List of social media accounts
+    """
+    try:
+        user_id = get_jwt_identity()
+        
+        # Check if Supabase client is initialized
+        if not hasattr(current_app, 'supabase') or current_app.supabase is None:
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': 'Database connection not initialized'
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 500
+        
+        # Fetch accounts from Supabase
+        response = (
+            current_app.supabase
+            .table("Social_network")
+            .select("*")
+            .eq("id_utilisateur", user_id)
+            .execute()
+        )
+        
+        accounts = response.data if response.data else []
+        
+        # Add CORS headers explicitly
+        response_data = jsonify({
+            'success': True,
+            'accounts': accounts
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 200
+        
+    except Exception as e:
+        current_app.logger.error(f"Get accounts error: {str(e)}")
+        # Add CORS headers to error response
+        response_data = jsonify({
+            'success': False,
+            'message': 'An error occurred while fetching accounts'
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 500
+
+@accounts_bp.route('/', methods=['POST'])
+@accounts_bp.route('', methods=['POST'])
+@jwt_required()
+def add_account():
+    """
+    Add a new social media account for the current user.
+    
+    Request Body:
+        account_name (str): Account name
+        social_network (str): Social network name
+        
+    Returns:
+        JSON: Add account result
+    """
+    try:
+        user_id = get_jwt_identity()
+        data = request.get_json()
+        
+        # Validate required fields
+        if not data or not all(k in data for k in ('account_name', 'social_network')):
+            return jsonify({
+                'success': False,
+                'message': 'Account name and social network are required'
+            }), 400
+        
+        account_name = data['account_name']
+        social_network = data['social_network']
+        
+        # For LinkedIn, initiate OAuth flow
+        if social_network.lower() == 'linkedin':
+            linkedin_service = LinkedInService()
+            # Generate a random state for security
+            state = secrets.token_urlsafe(32)
+            
+            # Store state in session or database for verification later
+            # For now, we'll return it to the frontend
+            authorization_url = linkedin_service.get_authorization_url(state)
+            
+            return jsonify({
+                'success': True,
+                'message': 'Please authenticate with LinkedIn',
+                'authorization_url': authorization_url,
+                'state': state
+            }), 200
+        else:
+            return jsonify({
+                'success': False,
+                'message': 'Unsupported social network'
+            }), 400
+        
+    except Exception as e:
+        current_app.logger.error(f"Add account error: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': f'An error occurred while adding account: {str(e)}'
+        }), 500
+
+@accounts_bp.route('/callback', methods=['POST'])
+@jwt_required()
+def handle_oauth_callback():
+    """
+    Handle OAuth callback from social network.
+    
+    Request Body:
+        code (str): Authorization code
+        state (str): State parameter
+        social_network (str): Social network name
+        
+    Returns:
+        JSON: OAuth callback result
+    """
+    try:
+        user_id = get_jwt_identity()
+        data = request.get_json()
+        
+        # Validate required fields
+        if not data or not all(k in data for k in ('code', 'state', 'social_network')):
+            return jsonify({
+                'success': False,
+                'message': 'Code, state, and social network are required'
+            }), 400
+        
+        code = data['code']
+        state = data['state']
+        social_network = data['social_network']
+        
+        # Verify state (in a real implementation, you would check against stored state)
+        # For now, we'll skip this verification
+        
+        if social_network.lower() == 'linkedin':
+            linkedin_service = LinkedInService()
+            
+            # Exchange code for access token
+            token_response = linkedin_service.get_access_token(code)
+            access_token = token_response['access_token']
+            
+            # Get user info
+            user_info = linkedin_service.get_user_info(access_token)
+            
+            # Store account info in Supabase
+            response = (
+                current_app.supabase
+                .table("Social_network")
+                .insert({
+                    "social_network": social_network,
+                    "account_name": user_info.get('name', 'LinkedIn Account'),
+                    "id_utilisateur": user_id,
+                    "token": access_token,
+                    "sub": user_info.get('sub'),
+                    "given_name": user_info.get('given_name'),
+                    "family_name": user_info.get('family_name'),
+                    "picture": user_info.get('picture')
+                })
+                .execute()
+            )
+            
+            if response.data:
+                return jsonify({
+                    'success': True,
+                    'message': 'Account linked successfully',
+                    'account': response.data[0]
+                }), 200
+            else:
+                return jsonify({
+                    'success': False,
+                    'message': 'Failed to link account'
+                }), 500
+        else:
+            return jsonify({
+                'success': False,
+                'message': 'Unsupported social network'
+            }), 400
+        
+    except Exception as e:
+        current_app.logger.error(f"OAuth callback error: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': f'An error occurred during OAuth callback: {str(e)}'
+        }), 500
+
+@accounts_bp.route('/<account_id>', methods=['OPTIONS'])
+def handle_account_options(account_id):
+    """Handle OPTIONS requests for preflight CORS checks for specific account."""
+    return '', 200
+
+@accounts_bp.route('/<account_id>', methods=['DELETE'])
+@jwt_required()
+def delete_account(account_id):
+    """
+    Delete a social media account.
+    
+    Path Parameters:
+        account_id (str): Account ID
+        
+    Returns:
+        JSON: Delete account result
+    """
+    try:
+        user_id = get_jwt_identity()
+        
+        # Delete account from Supabase
+        response = (
+            current_app.supabase
+            .table("Social_network")
+            .delete()
+            .eq("id", account_id)
+            .eq("id_utilisateur", user_id)
+            .execute()
+        )
+        
+        if response.data:
+            return jsonify({
+                'success': True,
+                'message': 'Account deleted successfully'
+            }), 200
+        else:
+            return jsonify({
+                'success': False,
+                'message': 'Account not found or unauthorized'
+            }), 404
+        
+    except Exception as e:
+        current_app.logger.error(f"Delete account error: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': 'An error occurred while deleting account'
+        }), 500
+
+@accounts_bp.route('/<account_id>/primary', methods=['OPTIONS'])
+def handle_primary_options(account_id):
+    """Handle OPTIONS requests for preflight CORS checks for primary account."""
+    return '', 200
+
+@accounts_bp.route('/<account_id>/primary', methods=['PUT'])
+@jwt_required()
+def set_primary_account(account_id):
+    """
+    Set an account as primary for the user.
+    
+    Path Parameters:
+        account_id (str): Account ID
+        
+    Returns:
+        JSON: Update result
+    """
+    try:
+        user_id = get_jwt_identity()
+        
+        # First, get all accounts for this user
+        response = (
+            current_app.supabase
+            .table("Social_network")
+            .select("*")
+            .eq("id_utilisateur", user_id)
+            .execute()
+        )
+        
+        accounts = response.data if response.data else []
+        
+        # Check if account exists and belongs to user
+        account_exists = any(account['id'] == account_id and account['id_utilisateur'] == user_id for account in accounts)
+        
+        if not account_exists:
+            return jsonify({
+                'success': False,
+                'message': 'Account not found or unauthorized'
+            }), 404
+        
+        # For now, we'll just return success
+        # In a real implementation, you might want to add a 'is_primary' field
+        # and update all accounts accordingly
+        
+        return jsonify({
+            'success': True,
+            'message': 'Account set as primary successfully'
+        }), 200
+        
+    except Exception as e:
+        current_app.logger.error(f"Set primary account error: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': 'An error occurred while setting primary account'
+        }), 500

backend/api/auth.py

@@ -0,0 +1,186 @@
+from flask import Blueprint, request, jsonify, current_app
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from services.auth_service import register_user, login_user, get_user_by_id
+from models.user import User
+
+auth_bp = Blueprint('auth', __name__)
+
+@auth_bp.route('/', methods=['OPTIONS'])
+def handle_options():
+    """Handle OPTIONS requests for preflight CORS checks."""
+    return '', 200
+
+@auth_bp.route('/register', methods=['OPTIONS'])
+def handle_register_options():
+    """Handle OPTIONS requests for preflight CORS checks for register route."""
+    return '', 200
+
+@auth_bp.route('/register', methods=['POST'])
+def register():
+    """
+    Register a new user.
+    
+    Request Body:
+        email (str): User email
+        password (str): User password
+        confirm_password (str): Password confirmation
+        
+    Returns:
+        JSON: Registration result
+    """
+    try:
+        data = request.get_json()
+        
+        # Validate required fields
+        if not data or not all(k in data for k in ('email', 'password', 'confirm_password')):
+            return jsonify({
+                'success': False,
+                'message': 'Email, password, and confirm_password are required'
+            }), 400
+        
+        email = data['email']
+        password = data['password']
+        confirm_password = data['confirm_password']
+        
+        # Validate password confirmation
+        if password != confirm_password:
+            return jsonify({
+                'success': False,
+                'message': 'Passwords do not match'
+            }), 400
+        
+        # Validate password length
+        if len(password) < 8:
+            return jsonify({
+                'success': False,
+                'message': 'Password must be at least 8 characters long'
+            }), 400
+        
+        # Register user
+        result = register_user(email, password)
+        
+        if result['success']:
+            return jsonify(result), 201
+        else:
+            return jsonify(result), 400
+            
+    except Exception as e:
+        current_app.logger.error(f"Registration error: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': 'An error occurred during registration'
+        }), 500
+
+@auth_bp.route('/login', methods=['OPTIONS'])
+def handle_login_options():
+    """Handle OPTIONS requests for preflight CORS checks for login route."""
+    return '', 200
+
+@auth_bp.route('/login', methods=['POST'])
+def login():
+    """
+    Authenticate and login a user.
+    
+    Request Body:
+        email (str): User email
+        password (str): User password
+        remember_me (bool): Remember me flag for extended session (optional)
+        
+    Returns:
+        JSON: Login result with JWT token
+    """
+    try:
+        data = request.get_json()
+        
+        # Validate required fields
+        if not data or not all(k in data for k in ('email', 'password')):
+            return jsonify({
+                'success': False,
+                'message': 'Email and password are required'
+            }), 400
+        
+        email = data['email']
+        password = data['password']
+        remember_me = data.get('remember_me', False)
+        
+        # Login user
+        result = login_user(email, password, remember_me)
+        
+        if result['success']:
+            # Set CORS headers explicitly
+            response_data = jsonify(result)
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 200
+        else:
+            return jsonify(result), 401
+            
+    except Exception as e:
+        current_app.logger.error(f"Login error: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': 'An error occurred during login'
+        }), 500
+
+@auth_bp.route('/logout', methods=['OPTIONS'])
+def handle_logout_options():
+    """Handle OPTIONS requests for preflight CORS checks for logout route."""
+    return '', 200
+
+@auth_bp.route('/logout', methods=['POST'])
+@jwt_required()
+def logout():
+    """
+    Logout current user.
+    
+    Returns:
+        JSON: Logout result
+    """
+    try:
+        return jsonify({
+            'success': True,
+            'message': 'Logged out successfully'
+        }), 200
+        
+    except Exception as e:
+        current_app.logger.error(f"Logout error: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': 'An error occurred during logout'
+        }), 500
+
+@auth_bp.route('/user', methods=['OPTIONS'])
+def handle_user_options():
+    """Handle OPTIONS requests for preflight CORS checks for user route."""
+    return '', 200
+
+@auth_bp.route('/user', methods=['GET'])
+@jwt_required()
+def get_current_user():
+    """
+    Get current authenticated user.
+    
+    Returns:
+        JSON: Current user data
+    """
+    try:
+        user_id = get_jwt_identity()
+        user_data = get_user_by_id(user_id)
+        
+        if user_data:
+            return jsonify({
+                'success': True,
+                'user': user_data
+            }), 200
+        else:
+            return jsonify({
+                'success': False,
+                'message': 'User not found'
+            }), 404
+            
+    except Exception as e:
+        current_app.logger.error(f"Get user error: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': 'An error occurred while fetching user data'
+        }), 500

backend/api/posts.py

@@ -0,0 +1,574 @@
+import codecs
+import uuid
+from flask import Blueprint, request, jsonify, current_app
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from services.content_service import ContentService
+from services.linkedin_service import LinkedInService
+
+posts_bp = Blueprint('posts', __name__)
+
+def safe_log_message(message):
+    """Safely log messages containing Unicode characters."""
+    try:
+        # Try to encode as UTF-8 first, then decode with error handling
+        if isinstance(message, str):
+            # For strings, try to encode and decode safely
+            encoded = message.encode('utf-8', errors='replace')
+            safe_message = encoded.decode('utf-8', errors='replace')
+        else:
+            # For non-strings, convert to string first
+            safe_message = str(message)
+        
+        # Log to app logger instead of print
+        current_app.logger.debug(safe_message)
+    except Exception as e:
+        # Ultimate fallback - log the error
+        current_app.logger.error(f"Failed to log message: {str(e)}")
+
+@posts_bp.route('/', methods=['OPTIONS'])
+@posts_bp.route('', methods=['OPTIONS'])
+def handle_options():
+    """Handle OPTIONS requests for preflight CORS checks."""
+    return '', 200
+
+@posts_bp.route('/', methods=['GET'])
+@posts_bp.route('', methods=['GET'])
+@jwt_required()
+def get_posts():
+    """
+    Get all posts for the current user.
+    
+    Query Parameters:
+        published (bool): Filter by published status
+        
+    Returns:
+        JSON: List of posts
+    """
+    try:
+        user_id = get_jwt_identity()
+        published = request.args.get('published', type=bool)
+        
+        # Check if Supabase client is initialized
+        if not hasattr(current_app, 'supabase') or current_app.supabase is None:
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': 'Database connection not initialized'
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 500
+        
+        # Build query
+        query = (
+            current_app.supabase
+            .table("Post_content")
+            .select("*, Social_network(id_utilisateur)")
+        )
+        
+        # Apply published filter if specified
+        if published is not None:
+            query = query.eq("is_published", published)
+        
+        response = query.execute()
+        
+        # Filter posts for the current user
+        user_posts = [
+            post for post in response.data
+            if post.get('Social_network', {}).get('id_utilisateur') == user_id
+        ] if response.data else []
+        
+        # Add CORS headers explicitly
+        response_data = jsonify({
+            'success': True,
+            'posts': user_posts
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 200
+        
+    except Exception as e:
+        error_message = str(e)
+        safe_log_message(f"Get posts error: {error_message}")
+        # Add CORS headers to error response
+        response_data = jsonify({
+            'success': False,
+            'message': 'An error occurred while fetching posts'
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 500
+        
+        # Add CORS headers explicitly
+        response_data = jsonify({
+            'success': True,
+            'posts': user_posts
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 200
+        
+    except Exception as e:
+        error_message = str(e)
+        safe_log_message(f"Get posts error: {error_message}")
+        # Add CORS headers to error response
+        response_data = jsonify({
+            'success': False,
+            'message': 'An error occurred while fetching posts'
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 500
+
+def _generate_post_task(user_id, job_id, job_store, hugging_key):
+    """
+    Background task to generate post content.
+    
+    Args:
+        user_id (str): User ID for personalization
+        job_id (str): Job ID to update status in job store
+        job_store (dict): Job store dictionary
+        hugging_key (str): Hugging Face API key
+    """
+    try:
+        # Update job status to processing
+        job_store[job_id] = {
+            'status': 'processing',
+            'result': None,
+            'error': None
+        }
+        
+        # Generate content using content service
+        # Pass the Hugging Face key directly to the service
+        content_service = ContentService(hugging_key=hugging_key)
+        generated_content = content_service.generate_post_content(user_id)
+        
+        # Update job status to completed with result
+        job_store[job_id] = {
+            'status': 'completed',
+            'result': generated_content,
+            'error': None
+        }
+        
+    except Exception as e:
+        error_message = str(e)
+        safe_log_message(f"Generate post background task error: {error_message}")
+        # Update job status to failed with error
+        job_store[job_id] = {
+            'status': 'failed',
+            'result': None,
+            'error': error_message
+        }
+
+@posts_bp.route('/generate', methods=['POST'])
+@jwt_required()
+def generate_post():
+    """
+    Generate a new post using AI asynchronously.
+    
+    Request Body:
+        user_id (str): User ID (optional, defaults to current user)
+        
+    Returns:
+        JSON: Job ID for polling
+    """
+    try:
+        current_user_id = get_jwt_identity()
+        data = request.get_json()
+        
+        # Use provided user_id or default to current user
+        user_id = data.get('user_id', current_user_id)
+        
+        # Verify user authorization (can only generate for self unless admin)
+        if user_id != current_user_id:
+            return jsonify({
+                'success': False,
+                'message': 'Unauthorized to generate posts for other users'
+            }), 403
+        
+        # Create a job ID
+        job_id = str(uuid.uuid4())
+        
+        # Initialize job status
+        current_app.job_store[job_id] = {
+            'status': 'pending',
+            'result': None,
+            'error': None
+        }
+        
+        # Get Hugging Face key
+        hugging_key = current_app.config['HUGGING_KEY']
+        
+        # Submit the background task, passing all necessary data
+        current_app.executor.submit(_generate_post_task, user_id, job_id, current_app.job_store, hugging_key)
+        
+        # Return job ID immediately
+        return jsonify({
+            'success': True,
+            'job_id': job_id,
+            'message': 'Post generation started'
+        }), 202  # 202 Accepted
+        
+    except Exception as e:
+        error_message = str(e)
+        safe_log_message(f"Generate post error: {error_message}")
+        return jsonify({
+            'success': False,
+            'message': f'An error occurred while starting post generation: {error_message}'
+        }), 500
+
+@posts_bp.route('/jobs/<job_id>', methods=['GET'])
+@jwt_required()
+def get_job_status(job_id):
+    """
+    Get the status of a post generation job.
+    
+    Path Parameters:
+        job_id (str): Job ID
+        
+    Returns:
+        JSON: Job status and result if completed
+    """
+    try:
+        # Get job from store
+        job = current_app.job_store.get(job_id)
+        
+        if not job:
+            return jsonify({
+                'success': False,
+                'message': 'Job not found'
+            }), 404
+            
+        # Prepare response
+        response_data = {
+            'success': True,
+            'job_id': job_id,
+            'status': job['status']
+        }
+        
+        # Include result or error if available
+        if job['status'] == 'completed':
+            response_data['content'] = job['result']
+        elif job['status'] == 'failed':
+            response_data['error'] = job['error']
+            
+        return jsonify(response_data), 200
+        
+    except Exception as e:
+        error_message = str(e)
+        safe_log_message(f"Get job status error: {error_message}")
+        return jsonify({
+            'success': False,
+            'message': f'An error occurred while fetching job status: {error_message}'
+        }), 500
+
+@posts_bp.route('/', methods=['OPTIONS'])
+@posts_bp.route('', methods=['OPTIONS'])
+def handle_create_options():
+    """Handle OPTIONS requests for preflight CORS checks for create post route."""
+    return '', 200
+
+@posts_bp.route('/publish-direct', methods=['OPTIONS'])
+def handle_publish_direct_options():
+    """Handle OPTIONS requests for preflight CORS checks for publish direct route."""
+    return '', 200
+
+@posts_bp.route('/publish-direct', methods=['POST'])
+@jwt_required()
+def publish_post_direct():
+    """
+    Publish a post directly to social media and save to database.
+    
+    Request Body:
+        social_account_id (str): Social account ID
+        text_content (str): Post text content
+        image_content_url (str, optional): Image URL
+        scheduled_at (str, optional): Scheduled time in ISO format
+        
+    Returns:
+        JSON: Publish post result
+    """
+    try:
+        user_id = get_jwt_identity()
+        data = request.get_json()
+        
+        # Validate required fields
+        social_account_id = data.get('social_account_id')
+        text_content = data.get('text_content')
+        
+        if not social_account_id or not text_content:
+            return jsonify({
+                'success': False,
+                'message': 'social_account_id and text_content are required'
+            }), 400
+        
+        # Verify the social account belongs to the user
+        account_response = (
+            current_app.supabase
+            .table("Social_network")
+            .select("id_utilisateur, token, sub")
+            .eq("id", social_account_id)
+            .execute()
+        )
+        
+        if not account_response.data:
+            return jsonify({
+                'success': False,
+                'message': 'Social account not found'
+            }), 404
+            
+        account = account_response.data[0]
+        if account.get('id_utilisateur') != user_id:
+            return jsonify({
+                'success': False,
+                'message': 'Unauthorized to use this social account'
+            }), 403
+        
+        # Get account details
+        access_token = account.get('token')
+        user_sub = account.get('sub')
+        
+        if not access_token or not user_sub:
+            return jsonify({
+                'success': False,
+                'message': 'Social account not properly configured'
+            }), 400
+        
+        # Get optional fields
+        image_url = data.get('image_content_url')
+        
+        # Publish to LinkedIn
+        linkedin_service = LinkedInService()
+        publish_response = linkedin_service.publish_post(
+            access_token, user_sub, text_content, image_url
+        )
+        
+        # Save to database as published
+        post_data = {
+            'id_social': social_account_id,
+            'Text_content': text_content,
+            'is_published': True
+        }
+        
+        # Add optional fields if provided
+        if image_url:
+            post_data['image_content_url'] = image_url
+            
+        if 'scheduled_at' in data:
+            post_data['scheduled_at'] = data['scheduled_at']
+        
+        # Insert post into database
+        response = (
+            current_app.supabase
+            .table("Post_content")
+            .insert(post_data)
+            .execute()
+        )
+        
+        if response.data:
+            # Add CORS headers explicitly
+            response_data = jsonify({
+                'success': True,
+                'message': 'Post published and saved successfully',
+                'post': response.data[0],
+                'linkedin_response': publish_response
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 201
+        else:
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': 'Failed to save post to database'
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 500
+            
+    except Exception as e:
+        error_message = str(e)
+        safe_log_message(f"[Post] Publish post directly error: {error_message}")
+        # Add CORS headers to error response
+        response_data = jsonify({
+            'success': False,
+            'message': f'An error occurred while publishing post: {error_message}'
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 500
+
+@posts_bp.route('/<post_id>', methods=['OPTIONS'])
+def handle_post_options(post_id):
+    """Handle OPTIONS requests for preflight CORS checks for specific post."""
+    return '', 200
+
+@posts_bp.route('/', methods=['POST'])
+@posts_bp.route('', methods=['POST'])
+@jwt_required()
+def create_post():
+    """
+    Create a new post.
+    
+    Request Body:
+        social_account_id (str): Social account ID
+        text_content (str): Post text content
+        image_content_url (str, optional): Image URL
+        scheduled_at (str, optional): Scheduled time in ISO format
+        is_published (bool, optional): Whether the post is published (defaults to True)
+        
+    Returns:
+        JSON: Created post data
+    """
+    try:
+        user_id = get_jwt_identity()
+        data = request.get_json()
+        
+        # Validate required fields
+        social_account_id = data.get('social_account_id')
+        text_content = data.get('text_content')
+        
+        if not social_account_id or not text_content:
+            return jsonify({
+                'success': False,
+                'message': 'social_account_id and text_content are required'
+            }), 400
+        
+        # Verify the social account belongs to the user
+        account_response = (
+            current_app.supabase
+            .table("Social_network")
+            .select("id_utilisateur")
+            .eq("id", social_account_id)
+            .execute()
+        )
+        
+        if not account_response.data:
+            return jsonify({
+                'success': False,
+                'message': 'Social account not found'
+            }), 404
+            
+        if account_response.data[0].get('id_utilisateur') != user_id:
+            return jsonify({
+                'success': False,
+                'message': 'Unauthorized to use this social account'
+            }), 403
+        
+        # Prepare post data - always mark as published
+        post_data = {
+            'id_social': social_account_id,
+            'Text_content': text_content,
+            'is_published': data.get('is_published', True)  # Default to True
+        }
+        
+        # Add optional fields if provided
+        if 'image_content_url' in data:
+            post_data['image_content_url'] = data['image_content_url']
+            
+        if 'scheduled_at' in data:
+            post_data['scheduled_at'] = data['scheduled_at']
+        
+        # Insert post into database
+        response = (
+            current_app.supabase
+            .table("Post_content")
+            .insert(post_data)
+            .execute()
+        )
+        
+        if response.data:
+            # Add CORS headers explicitly
+            response_data = jsonify({
+                'success': True,
+                'post': response.data[0]
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 201
+        else:
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': 'Failed to create post'
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 500
+            
+    except Exception as e:
+        error_message = str(e)
+        safe_log_message(f"[Post] Create post error: {error_message}")
+        # Add CORS headers to error response
+        response_data = jsonify({
+            'success': False,
+            'message': f'An error occurred while creating post: {error_message}'
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 500
+
+@posts_bp.route('/<post_id>', methods=['DELETE'])
+@jwt_required()
+def delete_post(post_id):
+    """
+    Delete a post.
+    
+    Path Parameters:
+        post_id (str): Post ID
+        
+    Returns:
+        JSON: Delete post result
+    """
+    try:
+        user_id = get_jwt_identity()
+        
+        # Verify the post belongs to the user
+        response = (
+            current_app.supabase
+            .table("Post_content")
+            .select("Social_network(id_utilisateur)")
+            .eq("id", post_id)
+            .execute()
+        )
+        
+        if not response.data:
+            return jsonify({
+                'success': False,
+                'message': 'Post not found'
+            }), 404
+        
+        post = response.data[0]
+        if post.get('Social_network', {}).get('id_utilisateur') != user_id:
+            return jsonify({
+                'success': False,
+                'message': 'Unauthorized to delete this post'
+            }), 403
+        
+        # Delete post from Supabase
+        delete_response = (
+            current_app.supabase
+            .table("Post_content")
+            .delete()
+            .eq("id", post_id)
+            .execute()
+        )
+        
+        if delete_response.data:
+            return jsonify({
+                'success': True,
+                'message': 'Post deleted successfully'
+            }), 200
+        else:
+            return jsonify({
+                'success': False,
+                'message': 'Failed to delete post'
+            }), 500
+        
+    except Exception as e:
+        error_message = str(e)
+        safe_log_message(f"Delete post error: {error_message}")
+        return jsonify({
+            'success': False,
+            'message': 'An error occurred while deleting post'
+        }), 500

backend/api/schedules.py

@@ -0,0 +1,233 @@
+from flask import Blueprint, request, jsonify, current_app
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from services.schedule_service import ScheduleService
+
+schedules_bp = Blueprint('schedules', __name__)
+
+@schedules_bp.route('/', methods=['OPTIONS'])
+@schedules_bp.route('', methods=['OPTIONS'])
+def handle_options():
+    """Handle OPTIONS requests for preflight CORS checks."""
+    return '', 200
+
+@schedules_bp.route('/', methods=['GET'])
+@schedules_bp.route('', methods=['GET'])
+@jwt_required()
+def get_schedules():
+    """
+    Get all schedules for the current user.
+    
+    Returns:
+        JSON: List of schedules
+    """
+    try:
+        user_id = get_jwt_identity()
+        print(f"[DEBUG] get_schedules called for user_id: {user_id}")
+        
+        # Check if Supabase client is initialized
+        if not hasattr(current_app, 'supabase') or current_app.supabase is None:
+            print("[ERROR] Supabase client not initialized")
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': 'Database connection not initialized'
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 500
+        
+        schedule_service = ScheduleService()
+        schedules = schedule_service.get_user_schedules(user_id)
+        print(f"[DEBUG] Found {len(schedules)} schedules for user {user_id}")
+        
+        # Add CORS headers explicitly
+        response_data = jsonify({
+            'success': True,
+            'schedules': schedules
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 200
+        
+    except Exception as e:
+        print(f"[ERROR] Get schedules error: {str(e)}")
+        import traceback
+        print(f"[ERROR] Full traceback: {traceback.format_exc()}")
+        current_app.logger.error(f"Get schedules error: {str(e)}")
+        # Add CORS headers to error response
+        response_data = jsonify({
+            'success': False,
+            'message': f'An error occurred while fetching schedules: {str(e)}',
+            'schedules': []  # Return empty array on error
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 500
+
+@schedules_bp.route('/', methods=['POST'])
+@schedules_bp.route('', methods=['POST'])
+@jwt_required()
+def create_schedule():
+    """
+    Create a new schedule for the current user.
+    
+    Request Body:
+        social_network (str): Social account ID
+        schedule_time (str): Schedule time in format "HH:MM"
+        days (List[str]): List of days to schedule
+        
+    Returns:
+        JSON: Create schedule result
+    """
+    try:
+        user_id = get_jwt_identity()
+        data = request.get_json()
+        
+        # Validate required fields
+        required_fields = ['social_network', 'schedule_time', 'days']
+        if not data or not all(k in data for k in required_fields):
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': 'Social network, schedule time, and days are required'
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 400
+        
+        social_network = data['social_network']
+        schedule_time = data['schedule_time']
+        days = data['days']
+        
+        # Validate days format
+        valid_days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+        if not isinstance(days, list) or not all(day in valid_days for day in days):
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': 'Days must be a list of valid day names'
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 400
+        
+        # Validate time format
+        try:
+            hour, minute = map(int, schedule_time.split(':'))
+            if hour < 0 or hour > 23 or minute < 0 or minute > 59:
+                raise ValueError
+        except ValueError:
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': 'Schedule time must be in format HH:MM (24-hour format)'
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 400
+        
+        # Create schedule using schedule service
+        schedule_service = ScheduleService()
+        result = schedule_service.create_schedule(user_id, social_network, schedule_time, days)
+        
+        if result['success']:
+            # Add CORS headers to success response
+            response_data = jsonify(result)
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 201
+        else:
+            # Add CORS headers to error response
+            response_data = jsonify(result)
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 400
+        
+    except Exception as e:
+        current_app.logger.error(f"Create schedule error: {str(e)}")
+        # Add CORS headers to error response
+        response_data = jsonify({
+            'success': False,
+            'message': f'An error occurred while creating schedule: {str(e)}'
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 500
+
+@schedules_bp.route('/<schedule_id>', methods=['OPTIONS'])
+def handle_schedule_options(schedule_id):
+    """Handle OPTIONS requests for preflight CORS checks for specific schedule."""
+    return '', 200
+
+@schedules_bp.route('/<schedule_id>', methods=['DELETE'])
+@jwt_required()
+def delete_schedule(schedule_id):
+    """
+    Delete a schedule.
+    
+    Path Parameters:
+        schedule_id (str): Schedule ID
+        
+    Returns:
+        JSON: Delete schedule result
+    """
+    try:
+        user_id = get_jwt_identity()
+        
+        # Verify the schedule belongs to the user
+        response = (
+            current_app.supabase
+            .table("Scheduling")
+            .select("Social_network(id_utilisateur)")
+            .eq("id", schedule_id)
+            .execute()
+        )
+        
+        if not response.data:
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': 'Schedule not found'
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 404
+        
+        schedule = response.data[0]
+        if schedule.get('Social_network', {}).get('id_utilisateur') != user_id:
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': 'Unauthorized to delete this schedule'
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 403
+        
+        # Delete schedule using schedule service
+        schedule_service = ScheduleService()
+        result = schedule_service.delete_schedule(schedule_id)
+        
+        if result['success']:
+            # Add CORS headers to success response
+            response_data = jsonify(result)
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 200
+        else:
+            # Add CORS headers to error response
+            response_data = jsonify(result)
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 404
+        
+    except Exception as e:
+        current_app.logger.error(f"Delete schedule error: {str(e)}")
+        # Add CORS headers to error response
+        response_data = jsonify({
+            'success': False,
+            'message': f'An error occurred while deleting schedule: {str(e)}'
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 500

backend/api/sources.py

@@ -0,0 +1,181 @@
+from flask import Blueprint, request, jsonify, current_app
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from services.content_service import ContentService
+import pandas as pd
+
+sources_bp = Blueprint('sources', __name__)
+
+@sources_bp.route('/', methods=['OPTIONS'])
+@sources_bp.route('', methods=['OPTIONS'])
+def handle_options():
+    """Handle OPTIONS requests for preflight CORS checks."""
+    return '', 200
+
+@sources_bp.route('/', methods=['GET'])
+@sources_bp.route('', methods=['GET'])
+@jwt_required()
+def get_sources():
+    """
+    Get all sources for the current user.
+    
+    Returns:
+        JSON: List of sources
+    """
+    try:
+        user_id = get_jwt_identity()
+        
+        # Check if Supabase client is initialized
+        if not hasattr(current_app, 'supabase') or current_app.supabase is None:
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': 'Database connection not initialized'
+            })
+            response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+            response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+            return response_data, 500
+        
+        # Fetch sources from Supabase
+        response = (
+            current_app.supabase
+            .table("Source")
+            .select("*")
+            .eq("user_id", user_id)
+            .execute()
+        )
+        
+        sources = response.data if response.data else []
+        
+        # Add CORS headers explicitly
+        response_data = jsonify({
+            'success': True,
+            'sources': sources
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 200
+        
+    except Exception as e:
+        current_app.logger.error(f"Get sources error: {str(e)}")
+        # Add CORS headers to error response
+        response_data = jsonify({
+            'success': False,
+            'message': 'An error occurred while fetching sources'
+        })
+        response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
+        response_data.headers.add('Access-Control-Allow-Credentials', 'true')
+        return response_data, 500
+
+@sources_bp.route('/', methods=['POST'])
+@sources_bp.route('', methods=['POST'])
+@jwt_required()
+def add_source():
+    """
+    Add a new source for the current user.
+    
+    Request Body:
+        source (str): Source URL
+        
+    Returns:
+        JSON: Add source result
+    """
+    try:
+        user_id = get_jwt_identity()
+        data = request.get_json()
+        
+        # Validate required fields
+        if not data or 'source' not in data:
+            return jsonify({
+                'success': False,
+                'message': 'Source URL is required'
+            }), 400
+        
+        source_url = data['source']
+        
+        # Use content service to add source
+        try:
+            content_service = ContentService()
+            result = content_service.add_rss_source(source_url, user_id)
+            
+            return jsonify({
+                'success': True,
+                'message': result
+            }), 201
+        except Exception as e:
+            # If content service fails, just store in database directly
+            current_app.logger.warning(f"Content service failed, storing in database directly: {str(e)}")
+            
+            # Store source directly in Supabase
+            response = (
+                current_app.supabase
+                .table("Source")
+                .insert({
+                    "url": source_url,
+                    "user_id": user_id,
+                    "created_at": "now()"
+                })
+                .execute()
+            )
+            
+            if response.data:
+                return jsonify({
+                    'success': True,
+                    'message': 'Source added successfully'
+                }), 201
+            else:
+                raise Exception("Failed to store source in database")
+        
+    except Exception as e:
+        current_app.logger.error(f"Add source error: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': f'An error occurred while adding source: {str(e)}'
+        }), 500
+
+@sources_bp.route('/<source_id>', methods=['OPTIONS'])
+def handle_source_options(source_id):
+    """Handle OPTIONS requests for preflight CORS checks for specific source."""
+    return '', 200
+
+@sources_bp.route('/<source_id>', methods=['DELETE'])
+@jwt_required()
+def delete_source(source_id):
+    """
+    Delete a source.
+    
+    Path Parameters:
+        source_id (str): Source ID
+        
+    Returns:
+        JSON: Delete source result
+    """
+    try:
+        user_id = get_jwt_identity()
+        
+        # Delete source from Supabase
+        response = (
+            current_app.supabase
+            .table("Source")
+            .delete()
+            .eq("id", source_id)
+            .eq("user_id", user_id)
+            .execute()
+        )
+        
+        if response.data:
+            return jsonify({
+                'success': True,
+                'message': 'Source deleted successfully'
+            }), 200
+        else:
+            return jsonify({
+                'success': False,
+                'message': 'Source not found or unauthorized'
+            }), 404
+        
+    except Exception as e:
+        current_app.logger.error(f"Delete source error: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': 'An error occurred while deleting source'
+        }), 500

backend/app.py

@@ -0,0 +1,139 @@
+import os
+import sys
+import locale
+from flask import Flask
+from flask_cors import CORS
+from flask_jwt_extended import JWTManager
+# Import for job handling
+import uuid
+from concurrent.futures import ThreadPoolExecutor
+
+from config import Config
+from utils.database import init_supabase
+from utils.cookies import setup_secure_cookies, configure_jwt_with_cookies
+
+# Celery imports
+from celery_app import celery
+
+def setup_unicode_environment():
+    """Setup Unicode environment for proper character handling."""
+    try:
+        # Set environment variables for UTF-8 support
+        os.environ['PYTHONIOENCODING'] = 'utf-8'
+        os.environ['PYTHONUTF8'] = '1'
+        
+        # Set locale to UTF-8 if available
+        try:
+            locale.setlocale(locale.LC_ALL, 'C.UTF-8')
+        except locale.Error:
+            try:
+                locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
+            except locale.Error:
+                try:
+                    locale.setlocale(locale.LC_ALL, '')
+                except locale.Error:
+                    pass
+        
+        # Set stdout/stderr encoding to UTF-8 if possible
+        if hasattr(sys.stdout, 'reconfigure'):
+            sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+            sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+        
+        # Log to app logger instead of print
+        if 'app' in globals():
+            app.logger.info("Unicode environment setup completed")
+    except Exception as e:
+        if 'app' in globals():
+            app.logger.warning(f"Unicode setup failed: {str(e)}")
+
+def create_app():
+    """Create and configure the Flask application."""
+    # Setup Unicode environment first
+    setup_unicode_environment()
+    
+    app = Flask(__name__)
+    app.config.from_object(Config)
+    
+    # Disable strict slashes to prevent redirects
+    app.url_map.strict_slashes = False
+    
+    # Initialize CORS with specific configuration
+    CORS(app, resources={
+        r"/api/*": {
+            "origins": [
+                "http://localhost:3000", 
+                "http://localhost:5000", 
+                "http://127.0.0.1:3000", 
+                "http://127.0.0.1:5000", 
+                "http://192.168.1.4:3000",
+                "https://zelyanoth-lin.hf.space"
+            ],
+            "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+            "allow_headers": ["Content-Type", "Authorization"],
+            "supports_credentials": True
+        }
+    })
+    
+    # Setup secure cookies
+    app = setup_secure_cookies(app)
+    
+    # Initialize JWT with cookie support
+    jwt = configure_jwt_with_cookies(app)
+    
+    # Initialize Supabase client
+    app.supabase = init_supabase(app.config['SUPABASE_URL'], app.config['SUPABASE_KEY'])
+    
+    # Initialize a simple in-memory job store for tracking async tasks
+    # In production, you'd use a database or Redis for this
+    app.job_store = {}
+    
+    # Initialize a ThreadPoolExecutor for running background tasks
+    # In production, you'd use a proper task queue like Celery
+    app.executor = ThreadPoolExecutor(max_workers=4)
+    
+    # Register blueprints
+    from api.auth import auth_bp
+    from api.sources import sources_bp
+    from api.accounts import accounts_bp
+    from api.posts import posts_bp
+    from api.schedules import schedules_bp
+    
+    app.register_blueprint(auth_bp, url_prefix='/api/auth')
+    app.register_blueprint(sources_bp, url_prefix='/api/sources')
+    app.register_blueprint(accounts_bp, url_prefix='/api/accounts')
+    app.register_blueprint(posts_bp, url_prefix='/api/posts')
+    app.register_blueprint(schedules_bp, url_prefix='/api/schedules')
+    
+    # Health check endpoint
+    @app.route('/health')
+    def health_check():
+        return {'status': 'healthy', 'message': 'Lin backend is running'}, 200
+    
+    # Add database connection check endpoint
+    @app.route('/api/health')
+    def api_health_check():
+        """Enhanced health check that includes database connection."""
+        try:
+            from utils.database import check_database_connection
+            db_connected = check_database_connection(app.supabase)
+            return {
+                'status': 'healthy' if db_connected else 'degraded',
+                'database': 'connected' if db_connected else 'disconnected',
+                'message': 'Lin backend is running' if db_connected else 'Database connection issues'
+            }, 200 if db_connected else 503
+        except Exception as e:
+            return {
+                'status': 'unhealthy',
+                'database': 'error',
+                'message': f'Health check failed: {str(e)}'
+            }, 503
+    
+    return app
+
+if __name__ == '__main__':
+    app = create_app()
+    app.run(
+        host='0.0.0.0',
+        port=int(os.environ.get('PORT', 5000)),
+        debug=app.config['DEBUG']
+    )

backend/app.py.bak

@@ -0,0 +1,141 @@
+import os
+import sys
+import locale
+from flask import Flask
+from flask_cors import CORS
+from flask_jwt_extended import JWTManager
+from apscheduler.schedulers.background import BackgroundScheduler
+import atexit
+# Import for job handling
+import uuid
+from concurrent.futures import ThreadPoolExecutor
+
+from config import Config
+from utils.database import init_supabase
+from utils.cookies import setup_secure_cookies, configure_jwt_with_cookies
+from scheduler.task_scheduler import init_scheduler
+
+def setup_unicode_environment():
+    """Setup Unicode environment for proper character handling."""
+    try:
+        # Set environment variables for UTF-8 support
+        os.environ['PYTHONIOENCODING'] = 'utf-8'
+        os.environ['PYTHONUTF8'] = '1'
+        
+        # Set locale to UTF-8 if available
+        try:
+            locale.setlocale(locale.LC_ALL, 'C.UTF-8')
+        except locale.Error:
+            try:
+                locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')
+            except locale.Error:
+                try:
+                    locale.setlocale(locale.LC_ALL, '')
+                except locale.Error:
+                    pass
+        
+        # Set stdout/stderr encoding to UTF-8 if possible
+        if hasattr(sys.stdout, 'reconfigure'):
+            sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+            sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+        
+        # Log to app logger instead of print
+        if 'app' in globals():
+            app.logger.info("Unicode environment setup completed")
+    except Exception as e:
+        if 'app' in globals():
+            app.logger.warning(f"Unicode setup failed: {str(e)}")
+
+def create_app():
+    """Create and configure the Flask application."""
+    # Setup Unicode environment first
+    setup_unicode_environment()
+    
+    app = Flask(__name__)
+    app.config.from_object(Config)
+    
+    # Disable strict slashes to prevent redirects
+    app.url_map.strict_slashes = False
+    
+    # Initialize CORS with specific configuration
+    CORS(app, resources={
+        r"/api/*": {
+            "origins": ["http://localhost:3000", "http://localhost:5000", "http://127.0.0.1:3000", "http://127.0.0.1:5000", "http://192.168.1.4:3000"],
+            "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+            "allow_headers": ["Content-Type", "Authorization"],
+            "supports_credentials": True
+        }
+    })
+    
+    # Setup secure cookies
+    app = setup_secure_cookies(app)
+    
+    # Initialize JWT with cookie support
+    jwt = configure_jwt_with_cookies(app)
+    
+    # Initialize Supabase client
+    app.supabase = init_supabase(app.config['SUPABASE_URL'], app.config['SUPABASE_KEY'])
+    
+    # Initialize a simple in-memory job store for tracking async tasks
+    # In production, you'd use a database or Redis for this
+    app.job_store = {}
+    
+    # Initialize a ThreadPoolExecutor for running background tasks
+    # In production, you'd use a proper task queue like Celery
+    app.executor = ThreadPoolExecutor(max_workers=4)
+    
+    # Initialize scheduler
+    if app.config['SCHEDULER_ENABLED']:
+        app.scheduler = BackgroundScheduler()
+        init_scheduler(app.scheduler, app.supabase)
+        app.scheduler.start()
+        
+        # Shut down the scheduler when exiting the app
+        atexit.register(lambda: app.scheduler.shutdown())
+    
+    # Register blueprints
+    from api.auth import auth_bp
+    from api.sources import sources_bp
+    from api.accounts import accounts_bp
+    from api.posts import posts_bp
+    from api.schedules import schedules_bp
+    
+    app.register_blueprint(auth_bp, url_prefix='/api/auth')
+    app.register_blueprint(sources_bp, url_prefix='/api/sources')
+    app.register_blueprint(accounts_bp, url_prefix='/api/accounts')
+    app.register_blueprint(posts_bp, url_prefix='/api/posts')
+    app.register_blueprint(schedules_bp, url_prefix='/api/schedules')
+    
+    # Health check endpoint
+    @app.route('/health')
+    def health_check():
+        return {'status': 'healthy', 'message': 'Lin backend is running'}, 200
+    
+    # Add database connection check endpoint
+    @app.route('/api/health')
+    def api_health_check():
+        """Enhanced health check that includes database connection."""
+        try:
+            from utils.database import check_database_connection
+            db_connected = check_database_connection(app.supabase)
+            return {
+                'status': 'healthy' if db_connected else 'degraded',
+                'database': 'connected' if db_connected else 'disconnected',
+                'message': 'Lin backend is running' if db_connected else 'Database connection issues'
+            }, 200 if db_connected else 503
+        except Exception as e:
+            return {
+                'status': 'unhealthy',
+                'database': 'error',
+                'message': f'Health check failed: {str(e)}'
+            }, 503
+    
+    return app
+
+if __name__ == '__main__':
+    app = create_app()
+    app.run(
+        host='0.0.0.0',
+        port=int(os.environ.get('PORT', 5000)),
+        debug=app.config['DEBUG']
+    )

backend/celery_app.py

@@ -0,0 +1,35 @@
+import os
+from celery import Celery
+from config import Config
+
+def make_celery(app_name=__name__):
+    """Create and configure the Celery application."""
+    # Create Celery instance
+    celery = Celery(app_name)
+    
+    # Configure Celery with broker and result backend from environment variables
+    celery.conf.broker_url = os.environ.get('CELERY_BROKER_URL', 'redis://localhost:6379/0')
+    celery.conf.result_backend = os.environ.get('CELERY_RESULT_BACKEND', 'redis://localhost:6379/0')
+    
+    # Additional Celery configuration
+    celery.conf.update(
+        task_serializer='json',
+        accept_content=['json'],
+        result_serializer='json',
+        timezone='UTC',
+        enable_utc=True,
+        task_routes={
+            'celery_tasks.content_tasks.generate_content': {'queue': 'content'},
+            'celery_tasks.publish_tasks.publish_post': {'queue': 'publish'},
+        },
+        worker_prefetch_multiplier=1,
+        task_acks_late=True,
+    )
+    
+    return celery
+
+# Create the Celery instance
+celery = make_celery()
+
+if __name__ == '__main__':
+    celery.start()

backend/celery_beat_config.py

@@ -0,0 +1,21 @@
+from celery import Celery
+from celery.schedules import crontab
+import os
+
+# Create Celery instance for Beat scheduler
+celery_beat = Celery('lin_scheduler')
+
+# Configure Celery Beat
+celery_beat.conf.broker_url = os.environ.get('CELERY_BROKER_URL', 'redis://localhost:6379/0')
+celery_beat.conf.result_backend = os.environ.get('CELERY_RESULT_BACKEND', 'redis://localhost:6379/0')
+
+# Configure schedules
+celery_beat.conf.beat_schedule = {
+    # This task will run every 5 minutes to load schedules from the database
+    'load-schedules': {
+        'task': 'load_schedules_task',
+        'schedule': crontab(minute='*/5'),
+    },
+}
+
+celery_beat.conf.timezone = 'UTC'

backend/celery_tasks/__init__.py

@@ -0,0 +1 @@
+# Initialize the celery_tasks package

backend/celery_tasks/content_tasks.py

@@ -0,0 +1,190 @@
+from celery import current_task
+from celery_app import celery
+from services.content_service import ContentService
+from services.linkedin_service import LinkedInService
+import logging
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+@celery.task(bind=True)
+def generate_content_task(self, user_id: str, schedule_id: str, supabase_client_config: dict):
+    """
+    Celery task to generate content for a scheduled post.
+    
+    Args:
+        user_id (str): User ID
+        schedule_id (str): Schedule ID
+        supabase_client_config (dict): Supabase client configuration
+        
+    Returns:
+        dict: Result of content generation
+    """
+    try:
+        logger.info(f"Starting content generation for schedule {schedule_id}")
+        
+        # Update task state
+        self.update_state(state='PROGRESS', meta={'status': 'Generating content...'})
+        
+        # Initialize content service
+        content_service = ContentService()
+        
+        # Generate content using content service
+        generated_content = content_service.generate_post_content(user_id)
+        
+        # Initialize Supabase client from config
+        from utils.database import init_supabase
+        supabase_client = init_supabase(
+            supabase_client_config['SUPABASE_URL'], 
+            supabase_client_config['SUPABASE_KEY']
+        )
+        
+        # Store generated content in database
+        # We need to get the social account ID from the schedule
+        schedule_response = (
+            supabase_client
+            .table("Scheduling")
+            .select("id_social")
+            .eq("id", schedule_id)
+            .execute()
+        )
+        
+        if not schedule_response.data:
+            raise Exception(f"Schedule {schedule_id} not found")
+            
+        social_account_id = schedule_response.data[0]['id_social']
+        
+        # Store the generated content
+        response = (
+            supabase_client
+            .table("Post_content")
+            .insert({
+                "social_account_id": social_account_id,
+                "Text_content": generated_content,
+                "is_published": False,
+                "sched": schedule_id
+            })
+            .execute()
+        )
+        
+        if response.data:
+            logger.info(f"Content generated and stored for schedule {schedule_id}")
+            return {
+                'status': 'success',
+                'message': f'Content generated for schedule {schedule_id}',
+                'post_id': response.data[0]['id']
+            }
+        else:
+            logger.error(f"Failed to store generated content for schedule {schedule_id}")
+            return {
+                'status': 'failure',
+                'message': f'Failed to store generated content for schedule {schedule_id}'
+            }
+            
+    except Exception as e:
+        logger.error(f"Error in content generation task for schedule {schedule_id}: {str(e)}")
+        return {
+            'status': 'failure',
+            'message': f'Error in content generation: {str(e)}'
+        }
+
+@celery.task(bind=True)
+def publish_post_task(self, schedule_id: str, supabase_client_config: dict):
+    """
+    Celery task to publish a scheduled post.
+    
+    Args:
+        schedule_id (str): Schedule ID
+        supabase_client_config (dict): Supabase client configuration
+        
+    Returns:
+        dict: Result of post publishing
+    """
+    try:
+        logger.info(f"Starting post publishing for schedule {schedule_id}")
+        
+        # Update task state
+        self.update_state(state='PROGRESS', meta={'status': 'Publishing post...'})
+        
+        # Initialize Supabase client from config
+        from utils.database import init_supabase
+        supabase_client = init_supabase(
+            supabase_client_config['SUPABASE_URL'], 
+            supabase_client_config['SUPABASE_KEY']
+        )
+        
+        # Fetch the post to publish
+        response = (
+            supabase_client
+            .table("Post_content")
+            .select("*")
+            .eq("sched", schedule_id)
+            .eq("is_published", False)
+            .order("created_at", desc=True)
+            .limit(1)
+            .execute()
+        )
+        
+        if not response.data:
+            logger.info(f"No unpublished posts found for schedule {schedule_id}")
+            return {
+                'status': 'info',
+                'message': f'No unpublished posts found for schedule {schedule_id}'
+            }
+        
+        post = response.data[0]
+        post_id = post.get('id')
+        text_content = post.get('Text_content')
+        image_url = post.get('image_content_url')
+        
+        # Get social network credentials
+        schedule_response = (
+            supabase_client
+            .table("Scheduling")
+            .select("Social_network(token, sub)")
+            .eq("id", schedule_id)
+            .execute()
+        )
+        
+        if not schedule_response.data:
+            raise Exception(f"Schedule {schedule_id} not found")
+            
+        social_network = schedule_response.data[0].get('Social_network', {})
+        access_token = social_network.get('token')
+        user_sub = social_network.get('sub')
+        
+        if not access_token or not user_sub:
+            logger.error(f"Missing social network credentials for schedule {schedule_id}")
+            return {
+                'status': 'failure',
+                'message': f'Missing social network credentials for schedule {schedule_id}'
+            }
+        
+        # Publish to LinkedIn
+        linkedin_service = LinkedInService()
+        publish_response = linkedin_service.publish_post(
+            access_token, user_sub, text_content, image_url
+        )
+        
+        # Update post status in database
+        update_response = (
+            supabase_client
+            .table("Post_content")
+            .update({"is_published": True})
+            .eq("id", post_id)
+            .execute()
+        )
+        
+        logger.info(f"Post published successfully for schedule {schedule_id}")
+        return {
+            'status': 'success',
+            'message': f'Post published successfully for schedule {schedule_id}',
+            'linkedin_response': publish_response
+        }
+        
+    except Exception as e:
+        logger.error(f"Error in publishing task for schedule {schedule_id}: {str(e)}")
+        return {
+            'status': 'failure',
+            'message': f'Error in publishing post: {str(e)}'
+        }

backend/celery_tasks/schedule_loader.py

@@ -0,0 +1,162 @@
+from celery import current_app
+from celery.schedules import crontab
+from datetime import datetime
+import logging
+from utils.database import init_supabase
+from config import Config
+from celery_tasks.scheduler import schedule_content_generation, schedule_post_publishing
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+def get_supabase_config():
+    """Get Supabase configuration from environment."""
+    return {
+        'SUPABASE_URL': Config.SUPABASE_URL,
+        'SUPABASE_KEY': Config.SUPABASE_KEY
+    }
+
+def parse_schedule_time(schedule_time):
+    """
+    Parse schedule time string into crontab format.
+    
+    Args:
+        schedule_time (str): Schedule time in format "Day HH:MM"
+        
+    Returns:
+        dict: Crontab parameters
+    """
+    try:
+        day_name, time_str = schedule_time.split()
+        hour, minute = map(int, time_str.split(':'))
+        
+        # Map day names to crontab format
+        day_map = {
+            'Monday': 1,
+            'Tuesday': 2,
+            'Wednesday': 3,
+            'Thursday': 4,
+            'Friday': 5,
+            'Saturday': 6,
+            'Sunday': 0
+        }
+        
+        day_of_week = day_map.get(day_name, '*')
+        
+        return {
+            'minute': minute,
+            'hour': hour,
+            'day_of_week': day_of_week
+        }
+    except Exception as e:
+        logger.error(f"Error parsing schedule time {schedule_time}: {str(e)}")
+        # Default to every minute for error cases
+        return {
+            'minute': '*',
+            'hour': '*',
+            'day_of_week': '*'
+        }
+
+def load_schedules_task():
+    """
+    Celery task to load schedules from the database and create periodic tasks.
+    This task runs every 5 minutes to check for new or updated schedules.
+    """
+    try:
+        logger.info("Loading schedules from database...")
+        
+        # Get Supabase configuration
+        supabase_config = get_supabase_config()
+        
+        # Initialize Supabase client
+        supabase_client = init_supabase(
+            supabase_config['SUPABASE_URL'],
+            supabase_config['SUPABASE_KEY']
+        )
+        
+        # Fetch all schedules from Supabase
+        response = (
+            supabase_client
+            .table("Scheduling")
+            .select("*, Social_network(id_utilisateur, token, sub)")
+            .execute()
+        )
+        
+        schedules = response.data if response.data else []
+        logger.info(f"Found {len(schedules)} schedules")
+        
+        # Get current beat schedule
+        current_schedule = current_app.conf.beat_schedule
+        
+        # Remove existing scheduled jobs (except the loader job)
+        # In a production environment, you might want to be more selective about this
+        loader_job = current_schedule.get('load-schedules', {})
+        new_schedule = {'load-schedules': loader_job}
+        
+        # Create jobs for each schedule
+        for schedule in schedules:
+            try:
+                schedule_id = schedule.get('id')
+                schedule_time = schedule.get('schedule_time')
+                adjusted_time = schedule.get('adjusted_time')
+                
+                if not schedule_time or not adjusted_time:
+                    logger.warning(f"Invalid schedule format for schedule {schedule_id}")
+                    continue
+                
+                # Parse schedule times
+                content_gen_time = parse_schedule_time(adjusted_time)
+                publish_time = parse_schedule_time(schedule_time)
+                
+                # Create content generation job (5 minutes before publishing)
+                gen_job_id = f"gen_{schedule_id}"
+                new_schedule[gen_job_id] = {
+                    'task': 'celery_tasks.content_tasks.generate_content_task',
+                    'schedule': crontab(
+                        minute=content_gen_time['minute'],
+                        hour=content_gen_time['hour'],
+                        day_of_week=content_gen_time['day_of_week']
+                    ),
+                    'args': (
+                        schedule.get('Social_network', {}).get('id_utilisateur'),
+                        schedule_id,
+                        supabase_config
+                    )
+                }
+                logger.info(f"Created content generation job: {gen_job_id}")
+                
+                # Create publishing job
+                pub_job_id = f"pub_{schedule_id}"
+                new_schedule[pub_job_id] = {
+                    'task': 'celery_tasks.content_tasks.publish_post_task',
+                    'schedule': crontab(
+                        minute=publish_time['minute'],
+                        hour=publish_time['hour'],
+                        day_of_week=publish_time['day_of_week']
+                    ),
+                    'args': (
+                        schedule_id,
+                        supabase_config
+                    )
+                }
+                logger.info(f"Created publishing job: {pub_job_id}")
+                
+            except Exception as e:
+                logger.error(f"Error creating jobs for schedule {schedule.get('id')}: {str(e)}")
+        
+        # Update the beat schedule
+        current_app.conf.beat_schedule = new_schedule
+        logger.info("Updated Celery Beat schedule")
+        
+        return {
+            'status': 'success',
+            'message': f'Loaded {len(schedules)} schedules',
+            'schedules_count': len(schedules)
+        }
+        
+    except Exception as e:
+        logger.error(f"Error loading schedules: {str(e)}")
+        return {
+            'status': 'error',
+            'message': f'Error loading schedules: {str(e)}'
+        }

backend/celery_tasks/scheduler.py

@@ -0,0 +1,105 @@
+from datetime import datetime, timedelta
+from celery import chain
+import logging
+from celery_app import celery
+from celery_tasks.content_tasks import generate_content_task, publish_post_task
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def init_celery_scheduler(supabase_client):
+    """
+    Initialize the Celery-based task scheduler.
+    
+    Args:
+        supabase_client: Supabase client instance
+    """
+    logger.info("Initializing Celery scheduler")
+    # In a Celery-based approach, we don't need to initialize a scheduler here
+    # Tasks will be scheduled through Celery Beat or called directly
+    
+def schedule_content_generation(schedule: dict, supabase_client_config: dict):
+    """
+    Schedule content generation task using Celery.
+    
+    Args:
+        schedule (dict): Schedule data
+        supabase_client_config (dict): Supabase client configuration
+        
+    Returns:
+        dict: Celery task result
+    """
+    schedule_id = schedule.get('id')
+    user_id = schedule.get('Social_network', {}).get('id_utilisateur')
+    
+    if not user_id:
+        logger.warning(f"No user ID found for schedule {schedule_id}")
+        return None
+    
+    logger.info(f"Scheduling content generation for schedule {schedule_id}")
+    
+    # Schedule the content generation task
+    task = generate_content_task.delay(user_id, schedule_id, supabase_client_config)
+    return {
+        'task_id': task.id,
+        'status': 'scheduled',
+        'message': f'Content generation scheduled for schedule {schedule_id}'
+    }
+
+def schedule_post_publishing(schedule: dict, supabase_client_config: dict):
+    """
+    Schedule post publishing task using Celery.
+    
+    Args:
+        schedule (dict): Schedule data
+        supabase_client_config (dict): Supabase client configuration
+        
+    Returns:
+        dict: Celery task result
+    """
+    schedule_id = schedule.get('id')
+    logger.info(f"Scheduling post publishing for schedule {schedule_id}")
+    
+    # Schedule the post publishing task
+    task = publish_post_task.delay(schedule_id, supabase_client_config)
+    return {
+        'task_id': task.id,
+        'status': 'scheduled',
+        'message': f'Post publishing scheduled for schedule {schedule_id}'
+    }
+
+def schedule_content_and_publish(schedule: dict, supabase_client_config: dict):
+    """
+    Schedule both content generation and post publishing as a chain.
+    
+    Args:
+        schedule (dict): Schedule data
+        supabase_client_config (dict): Supabase client configuration
+        
+    Returns:
+        dict: Celery task result
+    """
+    schedule_id = schedule.get('id')
+    user_id = schedule.get('Social_network', {}).get('id_utilisateur')
+    
+    if not user_id:
+        logger.warning(f"No user ID found for schedule {schedule_id}")
+        return None
+    
+    logger.info(f"Scheduling content generation and publishing chain for schedule {schedule_id}")
+    
+    # Create a chain of tasks: generate content first, then publish
+    task_chain = chain(
+        generate_content_task.s(user_id, schedule_id, supabase_client_config),
+        publish_post_task.s(supabase_client_config)
+    )
+    
+    # Apply the chain asynchronously
+    result = task_chain.apply_async()
+    
+    return {
+        'task_id': result.id,
+        'status': 'scheduled',
+        'message': f'Content generation and publishing chain scheduled for schedule {schedule_id}'
+    }

backend/config.py

@@ -0,0 +1,78 @@
+import os
+import platform
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+def get_system_encoding():
+    """Get the system's preferred encoding with UTF-8 fallback."""
+    try:
+        # Try to get the preferred encoding
+        import locale
+        preferred_encoding = locale.getpreferredencoding(False)
+        
+        # Ensure it's UTF-8 or a compatible encoding
+        if preferred_encoding.lower() not in ['utf-8', 'utf8', 'utf_8']:
+            # On Windows, try to set UTF-8
+            if platform.system() == 'Windows':
+                try:
+                    os.environ['PYTHONIOENCODING'] = 'utf-8'
+                    preferred_encoding = 'utf-8'
+                except:
+                    preferred_encoding = 'utf-8'
+            else:
+                preferred_encoding = 'utf-8'
+        
+        return preferred_encoding
+    except:
+        return 'utf-8'
+
+class Config:
+    """Base configuration class."""
+    
+    # Set default encoding
+    DEFAULT_ENCODING = get_system_encoding()
+    
+    # Supabase configuration
+    SUPABASE_URL = os.environ.get('SUPABASE_URL') or ''
+    SUPABASE_KEY = os.environ.get('SUPABASE_KEY') or ''
+    
+    # LinkedIn OAuth configuration
+    CLIENT_ID = os.environ.get('CLIENT_ID') or ''
+    CLIENT_SECRET = os.environ.get('CLIENT_SECRET') or ''
+    REDIRECT_URL = os.environ.get('REDIRECT_URL') or ''
+    
+    # Hugging Face configuration
+    HUGGING_KEY = os.environ.get('HUGGING_KEY') or ''
+    
+    # JWT configuration
+    JWT_SECRET_KEY = os.environ.get('JWT_SECRET_KEY') or 'your-secret-key-change-in-production'
+    
+    # Database configuration
+    DATABASE_URL = os.environ.get('DATABASE_URL') or ''
+    
+    # Application configuration
+    SECRET_KEY = os.environ.get('SECRET_KEY') or 'your-secret-key-change-in-production'
+    DEBUG = os.environ.get('DEBUG', 'False').lower() == 'true'
+    
+    # Scheduler configuration
+    SCHEDULER_ENABLED = os.environ.get('SCHEDULER_ENABLED', 'True').lower() == 'true'
+    
+    # Unicode/Encoding configuration
+    FORCE_UTF8 = os.environ.get('FORCE_UTF8', 'True').lower() == 'true'
+    UNICODE_LOGGING = os.environ.get('UNICODE_LOGGING', 'True').lower() == 'true'
+    
+    # Environment detection
+    ENVIRONMENT = os.environ.get('ENVIRONMENT', 'development').lower()
+    IS_WINDOWS = platform.system() == 'Windows'
+    IS_DOCKER = os.environ.get('DOCKER_CONTAINER', '').lower() == 'true'
+    
+    # Set environment-specific encoding settings
+    if FORCE_UTF8:
+        os.environ['PYTHONIOENCODING'] = 'utf-8'
+        os.environ['PYTHONUTF8'] = '1'
+    
+    # Debug and logging settings
+    LOG_LEVEL = os.environ.get('LOG_LEVEL', 'INFO' if ENVIRONMENT == 'production' else 'DEBUG')
+    UNICODE_SAFE_LOGGING = UNICODE_LOGGING and not IS_WINDOWS

backend/models/post.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+from typing import Optional
+from datetime import datetime
+
+@dataclass
+class Post:
+    """Post model representing a social media post."""
+    id: str
+    social_account_id: str
+    Text_content: str
+    is_published: bool = True
+    sched: Optional[str] = None
+    image_content_url: Optional[str] = None
+    created_at: Optional[datetime] = None
+    scheduled_at: Optional[datetime] = None
+    
+    @classmethod
+    def from_dict(cls, data: dict):
+        """Create a Post instance from a dictionary."""
+        return cls(
+            id=data['id'],
+            social_account_id=data['social_account_id'],
+            Text_content=data['Text_content'],
+            is_published=data.get('is_published', False),
+            sched=data.get('sched'),
+            image_content_url=data.get('image_content_url'),
+            created_at=datetime.fromisoformat(data['created_at'].replace('Z', '+00:00')) if data.get('created_at') else None,
+            scheduled_at=datetime.fromisoformat(data['scheduled_at'].replace('Z', '+00:00')) if data.get('scheduled_at') else None
+        )
+    
+    def to_dict(self):
+        """Convert Post instance to dictionary."""
+        return {
+            'id': self.id,
+            'social_account_id': self.social_account_id,
+            'Text_content': self.Text_content,
+            'is_published': self.is_published,
+            'sched': self.sched,
+            'image_content_url': self.image_content_url,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'scheduled_at': self.scheduled_at.isoformat() if self.scheduled_at else None
+        }

backend/models/schedule.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+from typing import Optional
+from datetime import datetime
+
+@dataclass
+class Schedule:
+    """Schedule model representing a post scheduling configuration."""
+    id: str
+    social_account_id: str
+    schedule_time: str
+    adjusted_time: str
+    created_at: Optional[datetime] = None
+    
+    @classmethod
+    def from_dict(cls, data: dict):
+        """Create a Schedule instance from a dictionary."""
+        return cls(
+            id=data['id'],
+            social_account_id=data['social_account_id'],
+            schedule_time=data['schedule_time'],
+            adjusted_time=data['adjusted_time'],
+            created_at=datetime.fromisoformat(data['created_at'].replace('Z', '+00:00')) if data.get('created_at') else None
+        )
+    
+    def to_dict(self):
+        """Convert Schedule instance to dictionary."""
+        return {
+            'id': self.id,
+            'social_account_id': self.social_account_id,
+            'schedule_time': self.schedule_time,
+            'adjusted_time': self.adjusted_time,
+            'created_at': self.created_at.isoformat() if self.created_at else None
+        }

backend/models/social_account.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+from typing import Optional
+from datetime import datetime
+
+@dataclass
+class SocialAccount:
+    """Social account model representing a social media account."""
+    id: str
+    user_id: str
+    social_network: str
+    account_name: str
+    token: Optional[str] = None
+    sub: Optional[str] = None
+    given_name: Optional[str] = None
+    family_name: Optional[str] = None
+    picture: Optional[str] = None
+    created_at: Optional[datetime] = None
+    
+    @classmethod
+    def from_dict(cls, data: dict):
+        """Create a SocialAccount instance from a dictionary."""
+        return cls(
+            id=data['id'],
+            user_id=data['user_id'],
+            social_network=data['social_network'],
+            account_name=data['account_name'],
+            token=data.get('token'),
+            sub=data.get('sub'),
+            given_name=data.get('given_name'),
+            family_name=data.get('family_name'),
+            picture=data.get('picture'),
+            created_at=datetime.fromisoformat(data['created_at'].replace('Z', '+00:00')) if data.get('created_at') else None
+        )
+    
+    def to_dict(self):
+        """Convert SocialAccount instance to dictionary."""
+        return {
+            'id': self.id,
+            'user_id': self.user_id,
+            'social_network': self.social_network,
+            'account_name': self.account_name,
+            'token': self.token,
+            'sub': self.sub,
+            'given_name': self.given_name,
+            'family_name': self.family_name,
+            'picture': self.picture,
+            'created_at': self.created_at.isoformat() if self.created_at else None
+        }

backend/models/source.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+from typing import Optional
+from datetime import datetime
+
+@dataclass
+class Source:
+    """Source model representing an RSS source."""
+    id: str
+    user_id: str
+    source: str
+    category: Optional[str] = None
+    last_update: Optional[datetime] = None
+    created_at: Optional[datetime] = None
+    
+    @classmethod
+    def from_dict(cls, data: dict):
+        """Create a Source instance from a dictionary."""
+        return cls(
+            id=data['id'],
+            user_id=data['user_id'],
+            source=data['source'],
+            category=data.get('category'),
+            last_update=datetime.fromisoformat(data['last_update'].replace('Z', '+00:00')) if data.get('last_update') else None,
+            created_at=datetime.fromisoformat(data['created_at'].replace('Z', '+00:00')) if data.get('created_at') else None
+        )
+    
+    def to_dict(self):
+        """Convert Source instance to dictionary."""
+        return {
+            'id': self.id,
+            'user_id': self.user_id,
+            'source': self.source,
+            'category': self.category,
+            'last_update': self.last_update.isoformat() if self.last_update else None,
+            'created_at': self.created_at.isoformat() if self.created_at else None
+        }

backend/models/user.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Optional
+from datetime import datetime
+
+@dataclass
+class User:
+    """User model representing a user in the system."""
+    id: str
+    email: str
+    created_at: datetime
+    email_confirmed_at: Optional[datetime] = None
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        """Create a User instance from a dictionary."""
+        return cls(
+            id=data['id'],
+            email=data['email'],
+            created_at=data['created_at'] if data.get('created_at') else None,
+            email_confirmed_at=data['email_confirmed_at'] if data.get('email_confirmed_at') else None
+        )
+
+    def to_dict(self):
+        """Convert User instance to dictionary."""
+        return {
+            'id': self.id,
+            'email': self.email,
+            'created_at': self.created_at if self.created_at else None,
+            'email_confirmed_at': self.email_confirmed_at if self.email_confirmed_at else None
+        }

backend/requirements.txt

@@ -0,0 +1,17 @@
+Flask>=2.3.2
+Flask-CORS>=4.0.0
+Flask-JWT-Extended>=4.5.2
+Flask-SQLAlchemy>=3.0.5
+Flask-Migrate>=4.0.4
+python-dotenv>=1.0.0
+requests>=2.31.0
+requests-oauthlib>=1.3.1
+apscheduler>=3.10.1
+pandas>=2.0.3
+gradio-client>=0.5.0
+supabase>=2.4.0
+bcrypt>=4.0.1
+pytest>=7.4.0
+pytest-cov>=4.1.0
+celery>=5.3.0
+redis>=4.5.0

backend/scheduler/task_scheduler.py

@@ -0,0 +1,269 @@
+import logging
+from datetime import datetime, timedelta
+from celery import current_app
+from celery.schedules import crontab
+from services.content_service import ContentService
+from services.linkedin_service import LinkedInService
+from config import Config
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def get_supabase_config():
+    """Get Supabase configuration from environment."""
+    return {
+        'SUPABASE_URL': Config.SUPABASE_URL,
+        'SUPABASE_KEY': Config.SUPABASE_KEY
+    }
+
+def init_scheduler(supabase_client):
+    """
+    Initialize the Celery-based task scheduler.
+    
+    Args:
+        supabase_client: Supabase client instance
+    """
+    logger.info("Initializing Celery scheduler")
+    # In a Celery-based approach, we don't need to initialize a scheduler here
+    # Tasks will be scheduled through Celery Beat or called directly
+
+def parse_schedule_time(schedule_time):
+    """
+    Parse schedule time string into crontab format.
+    
+    Args:
+        schedule_time (str): Schedule time in format "Day HH:MM"
+        
+    Returns:
+        dict: Crontab parameters
+    """
+    try:
+        day_name, time_str = schedule_time.split()
+        hour, minute = map(int, time_str.split(':'))
+        
+        # Map day names to crontab format
+        day_map = {
+            'Monday': 1,
+            'Tuesday': 2,
+            'Wednesday': 3,
+            'Thursday': 4,
+            'Friday': 5,
+            'Saturday': 6,
+            'Sunday': 0
+        }
+        
+        day_of_week = day_map.get(day_name, '*')
+        
+        return {
+            'minute': minute,
+            'hour': hour,
+            'day_of_week': day_of_week
+        }
+    except Exception as e:
+        logger.error(f"Error parsing schedule time {schedule_time}: {str(e)}")
+        # Default to every minute for error cases
+        return {
+            'minute': '*',
+            'hour': '*',
+            'day_of_week': '*'
+        }
+
+def load_schedules(supabase_client):
+    """
+    Load schedules from the database and create periodic tasks.
+    This function is called by the Celery Beat scheduler.
+    
+    Args:
+        supabase_client: Supabase client instance
+    """
+    try:
+        logger.info("Loading schedules from database...")
+        
+        # Get Supabase configuration
+        supabase_config = get_supabase_config()
+        
+        # Fetch all schedules from Supabase
+        response = (
+            supabase_client
+            .table("Scheduling")
+            .select("*, Social_network(id_utilisateur, token, sub)")
+            .execute()
+        )
+        
+        schedules = response.data if response.data else []
+        logger.info(f"Found {len(schedules)} schedules")
+        
+        # Get current beat schedule
+        current_schedule = current_app.conf.beat_schedule
+        
+        # Remove existing scheduled jobs (except the loader job)
+        # In a production environment, you might want to be more selective about this
+        loader_job = current_schedule.get('load-schedules', {})
+        new_schedule = {'load-schedules': loader_job}
+        
+        # Create jobs for each schedule
+        for schedule in schedules:
+            try:
+                schedule_id = schedule.get('id')
+                schedule_time = schedule.get('schedule_time')
+                adjusted_time = schedule.get('adjusted_time')
+                
+                if not schedule_time or not adjusted_time:
+                    logger.warning(f"Invalid schedule format for schedule {schedule_id}")
+                    continue
+                
+                # Parse schedule times
+                content_gen_time = parse_schedule_time(adjusted_time)
+                publish_time = parse_schedule_time(schedule_time)
+                
+                # Create content generation job (5 minutes before publishing)
+                gen_job_id = f"gen_{schedule_id}"
+                new_schedule[gen_job_id] = {
+                    'task': 'celery_tasks.content_tasks.generate_content_task',
+                    'schedule': crontab(
+                        minute=content_gen_time['minute'],
+                        hour=content_gen_time['hour'],
+                        day_of_week=content_gen_time['day_of_week']
+                    ),
+                    'args': (
+                        schedule.get('Social_network', {}).get('id_utilisateur'),
+                        schedule_id,
+                        supabase_config
+                    )
+                }
+                logger.info(f"Created content generation job: {gen_job_id}")
+                
+                # Create publishing job
+                pub_job_id = f"pub_{schedule_id}"
+                new_schedule[pub_job_id] = {
+                    'task': 'celery_tasks.content_tasks.publish_post_task',
+                    'schedule': crontab(
+                        minute=publish_time['minute'],
+                        hour=publish_time['hour'],
+                        day_of_week=publish_time['day_of_week']
+                    ),
+                    'args': (
+                        schedule_id,
+                        supabase_config
+                    )
+                }
+                logger.info(f"Created publishing job: {pub_job_id}")
+                
+            except Exception as e:
+                logger.error(f"Error creating jobs for schedule {schedule.get('id')}: {str(e)}")
+        
+        # Update the beat schedule
+        current_app.conf.beat_schedule = new_schedule
+        logger.info("Updated Celery Beat schedule")
+        
+    except Exception as e:
+        logger.error(f"Error loading schedules: {str(e)}")
+
+def generate_content_job(schedule: dict, supabase_client):
+    """
+    Job to generate content for a scheduled post.
+    This function is kept for backward compatibility but should be replaced with Celery tasks.
+    
+    Args:
+        schedule (dict): Schedule data
+        supabase_client: Supabase client instance
+    """
+    try:
+        schedule_id = schedule.get('id')
+        user_id = schedule.get('Social_network', {}).get('id_utilisateur')
+        
+        if not user_id:
+            logger.warning(f"No user ID found for schedule {schedule_id}")
+            return
+        
+        logger.info(f"Generating content for schedule {schedule_id}")
+        
+        # Generate content using content service
+        content_service = ContentService()
+        generated_content = content_service.generate_post_content(user_id)
+        
+        # Store generated content in database
+        social_account_id = schedule.get('id_social')
+        
+        response = (
+            supabase_client
+            .table("Post_content")
+            .insert({
+                "social_account_id": social_account_id,
+                "Text_content": generated_content,
+                "is_published": False,
+                "sched": schedule_id
+            })
+            .execute()
+        )
+        
+        if response.data:
+            logger.info(f"Content generated and stored for schedule {schedule_id}")
+        else:
+            logger.error(f"Failed to store generated content for schedule {schedule_id}")
+            
+    except Exception as e:
+        logger.error(f"Error in content generation job for schedule {schedule.get('id')}: {str(e)}")
+
+def publish_post_job(schedule: dict, supabase_client):
+    """
+    Job to publish a scheduled post.
+    This function is kept for backward compatibility but should be replaced with Celery tasks.
+    
+    Args:
+        schedule (dict): Schedule data
+        supabase_client: Supabase client instance
+    """
+    try:
+        schedule_id = schedule.get('id')
+        logger.info(f"Publishing post for schedule {schedule_id}")
+        
+        # Fetch the post to publish
+        response = (
+            supabase_client
+            .table("Post_content")
+            .select("*")
+            .eq("sched", schedule_id)
+            .eq("is_published", False)
+            .order("created_at", desc=True)
+            .limit(1)
+            .execute()
+        )
+        
+        if not response.data:
+            logger.info(f"No unpublished posts found for schedule {schedule_id}")
+            return
+        
+        post = response.data[0]
+        post_id = post.get('id')
+        text_content = post.get('Text_content')
+        image_url = post.get('image_content_url')
+        
+        # Get social network credentials
+        access_token = schedule.get('Social_network', {}).get('token')
+        user_sub = schedule.get('Social_network', {}).get('sub')
+        
+        if not access_token or not user_sub:
+            logger.error(f"Missing social network credentials for schedule {schedule_id}")
+            return
+        
+        # Publish to LinkedIn
+        linkedin_service = LinkedInService()
+        publish_response = linkedin_service.publish_post(
+            access_token, user_sub, text_content, image_url
+        )
+        
+        # Update post status in database
+        update_response = (
+            supabase_client
+            .table("Post_content")
+            .update({"is_published": True})
+            .eq("id", post_id)
+            .execute()
+        )
+        
+        logger.info(f"Post published successfully for schedule {schedule_id}")
+        
+    except Exception as e:
+        logger.error(f"Error in publishing job for schedule {schedule.get('id')}: {str(e)}")

backend/scheduler/task_scheduler.py.bak

@@ -0,0 +1,252 @@
+from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.triggers.cron import CronTrigger
+from datetime import datetime, timedelta
+import logging
+from services.content_service import ContentService
+from services.linkedin_service import LinkedInService
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def init_scheduler(scheduler: BackgroundScheduler, supabase_client):
+    """
+    Initialize the task scheduler with jobs.
+    
+    Args:
+        scheduler (BackgroundScheduler): The scheduler instance
+        supabase_client: Supabase client instance
+    """
+    # Add a job to load schedules from database
+    scheduler.add_job(
+        func=load_schedules,
+        trigger=CronTrigger(minute='*/5'),  # Run every 5 minutes
+        id='load_schedules',
+        name='Load schedules from database',
+        args=[scheduler, supabase_client]
+    )
+    
+    # Load initial schedules
+    load_schedules(scheduler, supabase_client)
+
+def load_schedules(scheduler: BackgroundScheduler, supabase_client):
+    """
+    Load schedules from the database and create jobs.
+    
+    Args:
+        scheduler (BackgroundScheduler): The scheduler instance
+        supabase_client: Supabase client instance
+    """
+    try:
+        logger.info("Loading schedules from database...")
+        
+        # Fetch all schedules from Supabase
+        response = (
+            supabase_client
+            .table("Scheduling")
+            .select("*, Social_network(id_utilisateur, token, sub)")
+            .execute()
+        )
+        
+        schedules = response.data if response.data else []
+        logger.info(f"Found {len(schedules)} schedules")
+        
+        # Remove existing scheduled jobs (except the loader job)
+        job_ids = [job.id for job in scheduler.get_jobs() if job.id != 'load_schedules']
+        for job_id in job_ids:
+            scheduler.remove_job(job_id)
+            logger.info(f"Removed job: {job_id}")
+        
+        # Create jobs for each schedule
+        for schedule in schedules:
+            try:
+                create_scheduling_jobs(scheduler, schedule, supabase_client)
+            except Exception as e:
+                logger.error(f"Error creating jobs for schedule {schedule.get('id')}: {str(e)}")
+                
+    except Exception as e:
+        logger.error(f"Error loading schedules: {str(e)}")
+
+def create_scheduling_jobs(scheduler: BackgroundScheduler, schedule: dict, supabase_client):
+    """
+    Create jobs for a specific schedule.
+    
+    Args:
+        scheduler (BackgroundScheduler): The scheduler instance
+        schedule (dict): Schedule data
+        supabase_client: Supabase client instance
+    """
+    schedule_id = schedule.get('id')
+    schedule_time = schedule.get('schedule_time')
+    adjusted_time = schedule.get('adjusted_time')
+    
+    if not schedule_time or not adjusted_time:
+        logger.warning(f"Invalid schedule format for schedule {schedule_id}")
+        return
+    
+    # Parse schedule times
+    try:
+        # Parse main schedule time (publishing)
+        day_name, time_str = schedule_time.split()
+        hour, minute = map(int, time_str.split(':'))
+        
+        # Parse adjusted time (content generation)
+        adj_day_name, adj_time_str = adjusted_time.split()
+        adj_hour, adj_minute = map(int, adj_time_str.split(':'))
+        
+        # Map day names to cron format
+        day_map = {
+            'Monday': 'mon',
+            'Tuesday': 'tue',
+            'Wednesday': 'wed',
+            'Thursday': 'thu',
+            'Friday': 'fri',
+            'Saturday': 'sat',
+            'Sunday': 'sun'
+        }
+        
+        if day_name not in day_map or adj_day_name not in day_map:
+            logger.warning(f"Invalid day name in schedule {schedule_id}")
+            return
+        
+        day_cron = day_map[day_name]
+        adj_day_cron = day_map[adj_day_name]
+        
+        # Create content generation job (5 minutes before publishing)
+        gen_job_id = f"gen_{schedule_id}"
+        scheduler.add_job(
+            func=generate_content_job,
+            trigger=CronTrigger(
+                day_of_week=adj_day_cron,
+                hour=adj_hour,
+                minute=adj_minute
+            ),
+            id=gen_job_id,
+            name=f"Generate content for schedule {schedule_id}",
+            args=[schedule, supabase_client]
+        )
+        logger.info(f"Created content generation job: {gen_job_id}")
+        
+        # Create publishing job
+        pub_job_id = f"pub_{schedule_id}"
+        scheduler.add_job(
+            func=publish_post_job,
+            trigger=CronTrigger(
+                day_of_week=day_cron,
+                hour=hour,
+                minute=minute
+            ),
+            id=pub_job_id,
+            name=f"Publish post for schedule {schedule_id}",
+            args=[schedule, supabase_client]
+        )
+        logger.info(f"Created publishing job: {pub_job_id}")
+        
+    except Exception as e:
+        logger.error(f"Error creating jobs for schedule {schedule_id}: {str(e)}")
+
+def generate_content_job(schedule: dict, supabase_client):
+    """
+    Job to generate content for a scheduled post.
+    
+    Args:
+        schedule (dict): Schedule data
+        supabase_client: Supabase client instance
+    """
+    try:
+        schedule_id = schedule.get('id')
+        user_id = schedule.get('Social_network', {}).get('id_utilisateur')
+        
+        if not user_id:
+            logger.warning(f"No user ID found for schedule {schedule_id}")
+            return
+        
+        logger.info(f"Generating content for schedule {schedule_id}")
+        
+        # Generate content using content service
+        content_service = ContentService()
+        generated_content = content_service.generate_post_content(user_id)
+        
+        # Store generated content in database
+        social_account_id = schedule.get('id_social')
+        
+        response = (
+            supabase_client
+            .table("Post_content")
+            .insert({
+                "social_account_id": social_account_id,
+                "Text_content": generated_content,
+                "is_published": False,
+                "sched": schedule_id
+            })
+            .execute()
+        )
+        
+        if response.data:
+            logger.info(f"Content generated and stored for schedule {schedule_id}")
+        else:
+            logger.error(f"Failed to store generated content for schedule {schedule_id}")
+            
+    except Exception as e:
+        logger.error(f"Error in content generation job for schedule {schedule.get('id')}: {str(e)}")
+
+def publish_post_job(schedule: dict, supabase_client):
+    """
+    Job to publish a scheduled post.
+    
+    Args:
+        schedule (dict): Schedule data
+        supabase_client: Supabase client instance
+    """
+    try:
+        schedule_id = schedule.get('id')
+        logger.info(f"Publishing post for schedule {schedule_id}")
+        
+        # Fetch the post to publish
+        response = (
+            supabase_client
+            .table("Post_content")
+            .select("*")
+            .eq("sched", schedule_id)
+            .eq("is_published", False)
+            .order("created_at", desc=True)
+            .limit(1)
+            .execute()
+        )
+        
+        if not response.data:
+            logger.info(f"No unpublished posts found for schedule {schedule_id}")
+            return
+        
+        post = response.data[0]
+        post_id = post.get('id')
+        text_content = post.get('Text_content')
+        image_url = post.get('image_content_url')
+        
+        # Get social network credentials
+        access_token = schedule.get('Social_network', {}).get('token')
+        user_sub = schedule.get('Social_network', {}).get('sub')
+        
+        if not access_token or not user_sub:
+            logger.error(f"Missing social network credentials for schedule {schedule_id}")
+            return
+        
+        # Publish to LinkedIn
+        linkedin_service = LinkedInService()
+        publish_response = linkedin_service.publish_post(
+            access_token, user_sub, text_content, image_url
+        )
+        
+        # Update post status in database
+        update_response = (
+            supabase_client
+            .table("Post_content")
+            .update({"is_published": True})
+            .eq("id", post_id)
+            .execute()
+        )
+        
+        logger.info(f"Post published successfully for schedule {schedule_id}")
+        
+    except Exception as e:
+        logger.error(f"Error in publishing job for schedule {schedule.get('id')}: {str(e)}")

backend/services/auth_service.py

@@ -0,0 +1,152 @@
+from flask import current_app, request
+from flask_jwt_extended import create_access_token, get_jwt
+import bcrypt
+from datetime import datetime, timedelta
+from models.user import User
+from utils.database import authenticate_user, create_user
+
+def register_user(email: str, password: str) -> dict:
+    """
+    Register a new user.
+    
+    Args:
+        email (str): User email
+        password (str): User password
+        
+    Returns:
+        dict: Registration result with user data or error message
+    """
+    try:
+        # Check if user already exists
+        # In Supabase, we'll try to create the user directly
+        response = create_user(current_app.supabase, email, password)
+        
+        if response.user:
+            user = User.from_dict({
+                'id': response.user.id,
+                'email': response.user.email,
+                'created_at': response.user.created_at
+            })
+            
+            return {
+                'success': True,
+                'message': 'User registered successfully. Please check your email for confirmation.',
+                'user': user.to_dict()
+            }
+        else:
+            return {
+                'success': False,
+                'message': 'Failed to register user'
+            }
+    except Exception as e:
+        # Check if it's a duplicate user error
+        if 'already registered' in str(e).lower():
+            return {
+                'success': False,
+                'message': 'User with this email already exists'
+            }
+        else:
+            return {
+                'success': False,
+                'message': f'Registration failed: {str(e)}'
+            }
+
+def login_user(email: str, password: str, remember_me: bool = False) -> dict:
+    """
+    Authenticate and login a user.
+    
+    Args:
+        email (str): User email
+        password (str): User password
+        remember_me (bool): Remember me flag for extended session
+        
+    Returns:
+        dict: Login result with token and user data or error message
+    """
+    try:
+        # Authenticate user with Supabase
+        response = authenticate_user(current_app.supabase, email, password)
+        
+        if response.user:
+            # Check if email is confirmed
+            if not response.user.email_confirmed_at:
+                return {
+                    'success': False,
+                    'message': 'Please confirm your email before logging in'
+                }
+            
+            # Set token expiration based on remember me flag
+            if remember_me:
+                # Extended token expiration (7 days)
+                expires_delta = timedelta(days=7)
+                token_type = "remember"
+            else:
+                # Standard token expiration (1 hour)
+                expires_delta = timedelta(hours=1)
+                token_type = "session"
+            
+            # Create JWT token with proper expiration and claims
+            access_token = create_access_token(
+                identity=response.user.id,
+                additional_claims={
+                    'email': response.user.email,
+                    'email_confirmed_at': response.user.email_confirmed_at.isoformat() if response.user.email_confirmed_at else None,
+                    'remember_me': remember_me,
+                    'token_type': token_type
+                },
+                expires_delta=expires_delta
+            )
+            
+            user = User.from_dict({
+                'id': response.user.id,
+                'email': response.user.email,
+                'created_at': response.user.created_at,
+                'email_confirmed_at': response.user.email_confirmed_at
+            })
+            
+            return {
+                'success': True,
+                'token': access_token,
+                'user': user.to_dict(),
+                'rememberMe': remember_me,
+                'expiresAt': (datetime.now() + expires_delta).isoformat(),
+                'tokenType': token_type
+            }
+        else:
+            return {
+                'success': False,
+                'message': 'Invalid email or password'
+            }
+    except Exception as e:
+        current_app.logger.error(f"Login error: {str(e)}")
+        return {
+            'success': False,
+            'message': f'Login failed: {str(e)}'
+        }
+
+def get_user_by_id(user_id: str) -> dict:
+    """
+    Get user by ID.
+    
+    Args:
+        user_id (str): User ID
+        
+    Returns:
+        dict: User data or None if not found
+    """
+    try:
+        # Get user from Supabase Auth
+        response = current_app.supabase.auth.get_user(user_id)
+        
+        if response.user:
+            user = User.from_dict({
+                'id': response.user.id,
+                'email': response.user.email,
+                'created_at': response.user.created_at,
+                'email_confirmed_at': response.user.email_confirmed_at
+            })
+            return user.to_dict()
+        else:
+            return None
+    except Exception:
+        return None

backend/services/content_service.py

@@ -0,0 +1,145 @@
+import re
+import json
+import unicodedata
+from flask import current_app
+from gradio_client import Client
+import pandas as pd
+
+class ContentService:
+    """Service for AI content generation using Hugging Face models."""
+    
+    def __init__(self, hugging_key=None):
+        # Use provided key or fall back to app config
+        self.hugging_key = hugging_key or current_app.config.get('HUGGING_KEY')
+        # Initialize the Gradio client for content generation
+        self.client = Client("Zelyanoth/Linkedin_poster_dev", hf_token=self.hugging_key)
+    
+    def validate_unicode_content(self, content):
+        """Validate Unicode content while preserving original formatting and spaces."""
+        if not content or not isinstance(content, str):
+            return content
+        
+        try:
+            # Test if content can be encoded as UTF-8
+            content.encode('utf-8')
+            return content  # Return original content if it's valid UTF-8
+        except UnicodeEncodeError:
+            try:
+                # If encoding fails, try to preserve as much as possible
+                return content.encode('utf-8', errors='replace').decode('utf-8')
+            except:
+                # Ultimate fallback
+                return str(content)
+    
+    def preserve_formatting(self, content):
+        """Preserve spaces, line breaks, and paragraph formatting."""
+        if not content:
+            return content
+        
+        # Preserve all whitespace characters including spaces, tabs, and newlines
+        # This ensures that paragraph breaks and indentation are maintained
+        try:
+            # Test encoding first
+            content.encode('utf-8')
+            return content
+        except UnicodeEncodeError:
+            # Fallback with error replacement but preserve whitespace
+            return content.encode('utf-8', errors='replace').decode('utf-8')
+    
+    def sanitize_content_for_api(self, content):
+        """Sanitize content for API calls while preserving original text, spaces, and formatting."""
+        if not content:
+            return content
+        
+        # First preserve formatting and spaces
+        preserved = self.preserve_formatting(content)
+        
+        # Only validate Unicode, don't remove spaces or formatting
+        validated = self.validate_unicode_content(preserved)
+        
+        # Only remove null bytes that might cause issues in API calls
+        if '\x00' in validated:
+            validated = validated.replace('\x00', '')
+        
+        # Ensure line breaks and spaces are preserved
+        validated = validated.replace('\r\n', '\n').replace('\r', '\n')
+        
+        return validated
+    
+    def generate_post_content(self, user_id: str) -> str:
+        """
+        Generate post content using AI.
+        
+        Args:
+            user_id (str): User ID for personalization
+            
+        Returns:
+            str: Generated post content
+        """
+        try:
+            # Call the Hugging Face model to generate content
+            result = self.client.predict(
+                code=user_id,
+                api_name="/poster_linkedin"
+            )
+            
+            # Parse the result (assuming it returns a list with content as first element)
+            # First try to parse as JSON
+            try:
+                parsed_result = json.loads(result)
+            except json.JSONDecodeError:
+                # If JSON parsing fails, check if it's already a Python list/object
+                try:
+                    # Try to evaluate as Python literal (safe for lists/dicts)
+                    import ast
+                    parsed_result = ast.literal_eval(result)
+                except (ValueError, SyntaxError):
+                    # If that fails, treat the result as a plain string
+                    parsed_result = [result]
+            
+            # Extract the first element if it's a list
+            if isinstance(parsed_result, list):
+                generated_content = parsed_result[0] if parsed_result and parsed_result[0] is not None else "Generated content will appear here..."
+            else:
+                generated_content = str(parsed_result) if parsed_result is not None else "Generated content will appear here..."
+                
+            # Validate, sanitize, and preserve formatting of the generated content
+            sanitized_content = self.sanitize_content_for_api(generated_content)
+            
+            # Ensure paragraph breaks and formatting are preserved
+            final_content = self.preserve_formatting(sanitized_content)
+            
+            return final_content
+            
+        except Exception as e:
+            error_message = str(e)
+            current_app.logger.error(f"Content generation failed: {error_message}")
+            raise Exception(f"Content generation failed: {error_message}")
+    
+    def add_rss_source(self, rss_link: str, user_id: str) -> str:
+        """
+        Add an RSS source for content generation.
+        
+        Args:
+            rss_link (str): RSS feed URL
+            user_id (str): User ID
+            
+        Returns:
+            str: Result message
+        """
+        try:
+            # Call the Hugging Face model to add RSS source
+            rss_input = f"{rss_link}__thi_irrh'èçs_my_id__! {user_id}"
+            sanitized_rss_input = self.sanitize_content_for_api(rss_input)
+            
+            result = self.client.predict(
+                rss_link=sanitized_rss_input,
+                api_name="/ajouter_rss"
+            )
+            
+            # Sanitize and preserve formatting of the result
+            sanitized_result = self.sanitize_content_for_api(result)
+            return self.preserve_formatting(sanitized_result)
+            
+        except Exception as e:
+            raise Exception(f"Failed to add RSS source: {str(e)}")

backend/services/linkedin_service.py

@@ -0,0 +1,181 @@
+from flask import current_app
+import requests
+from requests_oauthlib import OAuth2Session
+from urllib.parse import urlencode
+
+class LinkedInService:
+    """Service for LinkedIn API integration."""
+    
+    def __init__(self):
+        self.client_id = current_app.config['CLIENT_ID']
+        self.client_secret = current_app.config['CLIENT_SECRET']
+        self.redirect_uri = current_app.config['REDIRECT_URL']
+        self.scope = ['openid', 'profile', 'email', 'w_member_social']
+        
+    def get_authorization_url(self, state: str) -> str:
+        """
+        Get LinkedIn authorization URL.
+        
+        Args:
+            state (str): State parameter for security
+            
+        Returns:
+            str: Authorization URL
+        """
+        linkedin = OAuth2Session(
+            self.client_id,
+            redirect_uri=self.redirect_uri,
+            scope=self.scope,
+            state=state
+        )
+        
+        authorization_url, _ = linkedin.authorization_url(
+            'https://www.linkedin.com/oauth/v2/authorization'
+        )
+        
+        return authorization_url
+    
+    def get_access_token(self, code: str) -> dict:
+        """
+        Exchange authorization code for access token.
+        
+        Args:
+            code (str): Authorization code
+            
+        Returns:
+            dict: Token response
+        """
+        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": self.redirect_uri,
+            "client_id": self.client_id,
+            "client_secret": self.client_secret
+        }
+        
+        response = requests.post(url, headers=headers, data=data)
+        response.raise_for_status()
+        return response.json()
+    
+    def get_user_info(self, access_token: str) -> dict:
+        """
+        Get user information from LinkedIn.
+        
+        Args:
+            access_token (str): LinkedIn access token
+            
+        Returns:
+            dict: User information
+        """
+        url = "https://api.linkedin.com/v2/userinfo"
+        headers = {
+            "Authorization": f"Bearer {access_token}"
+        }
+        
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+        return response.json()
+    
+    def publish_post(self, access_token: str, user_id: str, text_content: str, image_url: str = None) -> dict:
+        """
+        Publish a post to LinkedIn.
+        
+        Args:
+            access_token (str): LinkedIn access token
+            user_id (str): LinkedIn user ID
+            text_content (str): Post content
+            image_url (str, optional): Image URL
+            
+        Returns:
+            dict: Publish response
+        """
+        url = "https://api.linkedin.com/v2/ugcPosts"
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+            "X-Restli-Protocol-Version": "2.0.0",
+            "Content-Type": "application/json"
+        }
+        
+        if image_url:
+            # Handle image upload
+            register_body = {
+                "registerUploadRequest": {
+                    "recipes": ["urn:li:digitalmediaRecipe:feedshare-image"],
+                    "owner": f"urn:li:person:{user_id}",
+                    "serviceRelationships": [{
+                        "relationshipType": "OWNER",
+                        "identifier": "urn:li:userGeneratedContent"
+                    }]
+                }
+            }
+            
+            r = requests.post(
+                "https://api.linkedin.com/v2/assets?action=registerUpload",
+                headers=headers,
+                json=register_body
+            )
+            
+            if r.status_code not in (200, 201):
+                raise Exception(f"Failed to register upload: {r.status_code} {r.text}")
+            
+            datar = r.json()["value"]
+            upload_url = datar["uploadMechanism"]["com.linkedin.digitalmedia.uploading.MediaUploadHttpRequest"]["uploadUrl"]
+            asset_urn = datar["asset"]
+            
+            # Upload image
+            upload_headers = {
+                "Authorization": f"Bearer {access_token}",
+                "X-Restli-Protocol-Version": "2.0.0",
+                "Content-Type": "application/octet-stream"
+            }
+            
+            # Download image and upload to LinkedIn
+            image_response = requests.get(image_url)
+            if image_response.status_code == 200:
+                upload_response = requests.put(upload_url, headers=upload_headers, data=image_response.content)
+                if upload_response.status_code not in (200, 201):
+                    raise Exception(f"Failed to upload image: {upload_response.status_code} {upload_response.text}")
+            
+            # Create post with image
+            post_body = {
+                "author": f"urn:li:person:{user_id}",
+                "lifecycleState": "PUBLISHED",
+                "specificContent": {
+                    "com.linkedin.ugc.ShareContent": {
+                        "shareCommentary": {"text": text_content},
+                        "shareMediaCategory": "IMAGE",
+                        "media": [{
+                            "status": "READY",
+                            "media": asset_urn,
+                            "description": {"text": "Post image"},
+                            "title": {"text": "Post image"}
+                        }]
+                    }
+                },
+                "visibility": {"com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"}
+            }
+        else:
+            # Create text-only post
+            post_body = {
+                "author": f"urn:li:person:{user_id}",
+                "lifecycleState": "PUBLISHED",
+                "specificContent": {
+                    "com.linkedin.ugc.ShareContent": {
+                        "shareCommentary": {
+                            "text": text_content
+                        },
+                        "shareMediaCategory": "NONE"
+                    }
+                },
+                "visibility": {
+                    "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"
+                }
+            }
+        
+        response = requests.post(url, headers=headers, json=post_body)
+        response.raise_for_status()
+        return response.json()