feat: add timezone support and improve logging

- Add timezone validation and support in schedule creation
- Replace print statements with proper logging
- Configure logging levels for better control
- Add timezone utilities for handling user timezones
- Improve error handling and user feedback
- Update scheduler service to handle timezone information
```

This commit message follows the conventional commit format and provides a clear summary of the changes made, including the addition of timezone support and improved logging throughout the application. It explains what was changed and why, making it easier for other developers to understand the purpose of these modifications.

backend/api/schedules.py

@@ -1,8 +1,11 @@
 from flask import Blueprint, request, jsonify, current_app
 from flask_jwt_extended import jwt_required, get_jwt_identity
 from backend.services.schedule_service import ScheduleService
+from backend.utils.timezone_utils import validate_timezone, get_server_timezone, format_timezone_schedule
+import logging
 
 schedules_bp = Blueprint('schedules', __name__)
+logger = logging.getLogger(__name__)
 
 @schedules_bp.route('/', methods=['OPTIONS'])
 @schedules_bp.route('', methods=['OPTIONS'])
@@ -22,11 +25,11 @@ def get_schedules():
     """
     try:
         user_id = get_jwt_identity()
-        print(f"[DEBUG] get_schedules called for user_id: {user_id}")
+        logger.info(f"📋 Fetching schedules for user: {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")
+            logger.error("❌ Supabase client not initialized")
             # Add CORS headers to error response
             response_data = jsonify({
                 'success': False,
@@ -38,7 +41,7 @@ def get_schedules():
         
         schedule_service = ScheduleService()
         schedules = schedule_service.get_user_schedules(user_id)
-        print(f"[DEBUG] Found {len(schedules)} schedules for user {user_id}")
+        logger.info(f"✅ Found {len(schedules)} schedules for user {user_id}")
         
         # Add CORS headers explicitly
         response_data = jsonify({
@@ -50,9 +53,9 @@ def get_schedules():
         return response_data, 200
         
     except Exception as e:
-        print(f"[ERROR] Get schedules error: {str(e)}")
+        logger.error(f"❌ Get schedules error: {str(e)}")
         import traceback
-        print(f"[ERROR] Full traceback: {traceback.format_exc()}")
+        logger.error(f"Full traceback: {traceback.format_exc()}")
         current_app.logger.error(f"Get schedules error: {str(e)}")
         # Add CORS headers to error response
         response_data = jsonify({
@@ -95,6 +98,20 @@ def create_schedule():
             response_data.headers.add('Access-Control-Allow-Credentials', 'true')
             return response_data, 400
         
+        # Get timezone information (optional, will use server timezone if not provided)
+        user_timezone = data.get('timezone', get_server_timezone())
+        
+        # Validate timezone if provided
+        if user_timezone and not validate_timezone(user_timezone):
+            # Add CORS headers to error response
+            response_data = jsonify({
+                'success': False,
+                'message': f'Invalid timezone: {user_timezone}'
+            })
+            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']
@@ -128,12 +145,12 @@ def create_schedule():
         
         # Create schedule using schedule service
         schedule_service = ScheduleService()
-        result = schedule_service.create_schedule(user_id, social_network, schedule_time, days)
+        result = schedule_service.create_schedule(user_id, social_network, schedule_time, days, user_timezone)
         
         if result['success']:
             # Trigger immediate APScheduler update
             try:
-                print("[INFO] Triggering immediate APScheduler update...")
+                logger.info("🔄 Triggering immediate APScheduler update...")
                 if hasattr(current_app, 'scheduler'):
                     scheduler_updated = current_app.scheduler.trigger_immediate_update()
                     if scheduler_updated:
@@ -143,7 +160,7 @@ def create_schedule():
                 else:
                     result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
             except Exception as e:
-                print(f"[WARNING] Failed to trigger immediate scheduler update: {str(e)}")
+                logger.warning(f"⚠️ Failed to trigger immediate scheduler update: {str(e)}")
                 # Don't fail the schedule creation if scheduler update fails
                 result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
             
@@ -227,7 +244,7 @@ def delete_schedule(schedule_id):
         if result['success']:
             # Trigger immediate APScheduler update
             try:
-                print("[INFO] Triggering immediate APScheduler update after deletion...")
+                logger.info("🔄 Triggering immediate APScheduler update after deletion...")
                 if hasattr(current_app, 'scheduler'):
                     scheduler_updated = current_app.scheduler.trigger_immediate_update()
                     if scheduler_updated:
@@ -237,7 +254,7 @@ def delete_schedule(schedule_id):
                 else:
                     result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
             except Exception as e:
-                print(f"[WARNING] Failed to trigger immediate scheduler update: {str(e)}")
+                logger.warning(f"⚠️ Failed to trigger immediate scheduler update: {str(e)}")
                 # Don't fail the schedule deletion if scheduler update fails
                 result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
             

backend/app.py

@@ -9,12 +9,12 @@ from flask_jwt_extended import JWTManager
 import uuid
 from concurrent.futures import ThreadPoolExecutor
 
-# Configure logging for APScheduler
+# Configure logging for APScheduler - only show essential logs
 logging.basicConfig(
-    level=logging.DEBUG,
+    level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 )
-logging.getLogger('apscheduler').setLevel(logging.DEBUG)
+logging.getLogger('apscheduler').setLevel(logging.WARNING)
 
 # Use relative import for the Config class to work with Hugging Face Spaces
 from backend.config import Config

backend/scheduler/apscheduler_service.py

@@ -10,6 +10,12 @@ from backend.services.content_service import ContentService
 from backend.services.linkedin_service import LinkedInService
 from backend.utils.database import init_supabase
 from backend.config import Config
+from backend.utils.timezone_utils import (
+    parse_timezone_schedule,
+    get_server_timezone,
+    convert_time_to_timezone,
+    validate_timezone
+)
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -31,15 +37,13 @@ class APSchedulerService:
         try:
             self.app = app
             
-            logger.info("Initializing APScheduler...")
+            logger.info("🚀 APScheduler starting...")
             
             # Initialize Supabase client
-            logger.info("Initializing Supabase client...")
             self.supabase_client = init_supabase(
                 app.config['SUPABASE_URL'],
                 app.config['SUPABASE_KEY']
             )
-            logger.info("Supabase client initialized")
             
             # Configure job stores and executors
             jobstores = {
@@ -56,26 +60,21 @@ class APSchedulerService:
             }
             
             # Create scheduler
-            logger.info("Creating BackgroundScheduler...")
             self.scheduler = BackgroundScheduler(
                 jobstores=jobstores,
                 executors=executors,
                 job_defaults=job_defaults,
                 timezone='UTC'
             )
-            logger.info("BackgroundScheduler created")
             
             # Add the scheduler to the app
             app.scheduler = self
-            logger.info("Scheduler added to app")
             
             # Start the scheduler
-            logger.info("Starting scheduler...")
             self.scheduler.start()
-            logger.info("Scheduler started")
+            logger.info("✅ APScheduler started successfully")
             
             # Add the periodic job to load schedules from database
-            logger.info("Adding periodic job to load schedules...")
             self.scheduler.add_job(
                 func=self.load_schedules,
                 trigger=CronTrigger(minute='*/5'),  # Every 5 minutes
@@ -83,26 +82,20 @@ class APSchedulerService:
                 name='Load schedules from database',
                 replace_existing=True
             )
-            logger.info("Periodic job added")
             
             # Load schedules immediately when the app starts
-            logger.info("Loading schedules immediately...")
             self.load_schedules()
-            logger.info("Schedules loaded immediately")
             
-            logger.info("APS Scheduler initialized, started, and schedules loaded")
         except Exception as e:
-            logger.error(f"Error initializing APScheduler: {str(e)}")
+            logger.error(f"❌ APScheduler initialization failed: {str(e)}")
             import traceback
             logger.error(traceback.format_exc())
     
     def load_schedules(self):
         """Load schedules from the database and create jobs."""
         try:
-            logger.info("Loading schedules from database...")
-            
             if not self.supabase_client:
-                logger.error("Supabase client not initialized")
+                logger.error("❌ Supabase client not initialized")
                 return
             
             # Fetch all schedules from Supabase
@@ -114,7 +107,7 @@ class APSchedulerService:
             )
             
             schedules = response.data if response.data else []
-            logger.info(f"Found {len(schedules)} schedules in database")
+            logger.info(f"📋 Found {len(schedules)} schedules in database")
             
             # Remove existing scheduled jobs (except the loader job)
             jobs_to_remove = []
@@ -125,7 +118,6 @@ class APSchedulerService:
             for job_id in jobs_to_remove:
                 try:
                     self.scheduler.remove_job(job_id)
-                    logger.info(f"Removed job: {job_id}")
                 except Exception as e:
                     logger.warning(f"Failed to remove job {job_id}: {str(e)}")
             
@@ -137,12 +129,26 @@ class APSchedulerService:
                     adjusted_time = schedule.get('adjusted_time')
                     
                     if not schedule_time or not adjusted_time:
-                        logger.warning(f"Invalid schedule format for schedule {schedule_id}")
+                        logger.warning(f"⚠️ Invalid schedule format for schedule {schedule_id}")
                         continue
                     
-                    # Parse schedule times
-                    content_gen_cron = self._parse_schedule_time(adjusted_time)
-                    publish_cron = self._parse_schedule_time(schedule_time)
+                    # Parse timezone information
+                    server_timezone = get_server_timezone()
+                    schedule_time_part, schedule_timezone = parse_timezone_schedule(schedule_time)
+                    adjusted_time_part, adjusted_timezone = parse_timezone_schedule(adjusted_time)
+                    
+                    # Convert to server timezone for APScheduler
+                    if schedule_timezone and validate_timezone(schedule_timezone):
+                        server_schedule_time = convert_time_to_timezone(schedule_time_part, schedule_timezone, server_timezone)
+                        server_adjusted_time = convert_time_to_timezone(adjusted_time_part, adjusted_timezone or schedule_timezone, server_timezone)
+                    else:
+                        # Use original time if no valid timezone
+                        server_schedule_time = schedule_time_part
+                        server_adjusted_time = adjusted_time_part
+                    
+                    # Parse schedule times for server timezone
+                    content_gen_cron = self._parse_schedule_time(server_adjusted_time)
+                    publish_cron = self._parse_schedule_time(server_schedule_time)
                     
                     # Create content generation job (5 minutes before publishing)
                     gen_job_id = f"gen_{schedule_id}"
@@ -158,7 +164,6 @@ class APSchedulerService:
                         args=[schedule.get('Social_network', {}).get('id_utilisateur'), schedule_id],
                         replace_existing=True
                     )
-                    logger.info(f"Created content generation job: {gen_job_id}")
                     
                     # Create publishing job
                     pub_job_id = f"pub_{schedule_id}"
@@ -174,15 +179,14 @@ class APSchedulerService:
                         args=[schedule_id],
                         replace_existing=True
                     )
-                    logger.info(f"Created publishing job: {pub_job_id}")
+                    
+                    logger.info(f"📅 Created schedule jobs for {schedule_id}")
                     
                 except Exception as e:
-                    logger.error(f"Error creating jobs for schedule {schedule.get('id')}: {str(e)}")
-            
-            logger.info("Updated APScheduler schedule")
+                    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)}")
+            logger.error(f"❌ Error loading schedules: {str(e)}")
     
     def _parse_schedule_time(self, schedule_time):
         """
@@ -233,7 +237,7 @@ class APSchedulerService:
             schedule_id (str): Schedule ID
         """
         try:
-            logger.info(f"Starting content generation for schedule {schedule_id}")
+            logger.info(f"🎨 Generating content for schedule {schedule_id}")
             
             # Initialize content service
             content_service = ContentService()
@@ -270,12 +274,12 @@ class APSchedulerService:
             )
             
             if response.data:
-                logger.info(f"Content generated and stored for schedule {schedule_id}")
+                logger.info(f"✅ Content generated and stored for schedule {schedule_id}")
             else:
-                logger.error(f"Failed to store generated content for schedule {schedule_id}")
+                logger.error(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)}")
+            logger.error(f"❌ Error in content generation task for schedule {schedule_id}: {str(e)}")
     
     def publish_post_task(self, schedule_id: str):
         """
@@ -285,7 +289,7 @@ class APSchedulerService:
             schedule_id (str): Schedule ID
         """
         try:
-            logger.info(f"Starting post publishing for schedule {schedule_id}")
+            logger.info(f"🚀 Publishing post for schedule {schedule_id}")
             
             # Fetch the post to publish
             response = (
@@ -300,7 +304,7 @@ class APSchedulerService:
             )
             
             if not response.data:
-                logger.info(f"No unpublished posts found for schedule {schedule_id}")
+                logger.info(f"📭 No unpublished posts found for schedule {schedule_id}")
                 return
             
             post = response.data[0]
@@ -325,7 +329,7 @@ class APSchedulerService:
             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}")
+                logger.error(f"❌ Missing social network credentials for schedule {schedule_id}")
                 return
             
             # Publish to LinkedIn
@@ -343,24 +347,23 @@ class APSchedulerService:
                 .execute()
             )
             
-            logger.info(f"Post published successfully for schedule {schedule_id}")
+            logger.info(f"✅ Post published successfully for schedule {schedule_id}")
             
         except Exception as e:
-            logger.error(f"Error in publishing task for schedule {schedule_id}: {str(e)}")
+            logger.error(f"❌ Error in publishing task for schedule {schedule_id}: {str(e)}")
     
     def trigger_immediate_update(self):
         """Trigger immediate schedule update."""
         try:
-            logger.info("Triggering immediate schedule update...")
+            logger.info("🔄 Triggering immediate schedule update...")
             self.load_schedules()
-            logger.info("Immediate schedule update completed")
             return True
         except Exception as e:
-            logger.error(f"Error triggering immediate schedule update: {str(e)}")
+            logger.error(f"❌ Error triggering immediate schedule update: {str(e)}")
             return False
     
     def shutdown(self):
         """Shutdown the scheduler."""
         if self.scheduler:
             self.scheduler.shutdown()
-            logger.info("APS Scheduler shutdown")
+            logger.info("🛑 APS Scheduler shutdown")

backend/services/schedule_service.py

@@ -3,6 +3,13 @@ from datetime import datetime, timedelta
 from typing import List, Dict
 import pandas as pd
 from backend.models.schedule import Schedule
+from backend.utils.timezone_utils import (
+    validate_timezone,
+    format_timezone_schedule,
+    calculate_adjusted_time_with_timezone,
+    get_server_timezone,
+    parse_timezone_schedule
+)
 
 class ScheduleService:
     """Service for managing post scheduling."""
@@ -49,7 +56,7 @@ class ScheduleService:
             # Return empty list instead of raising exception
             return []
     
-    def create_schedule(self, user_id: str, social_network: str, schedule_time: str, days: List[str]) -> Dict:
+    def create_schedule(self, user_id: str, social_network: str, schedule_time: str, days: List[str], timezone: str = None) -> Dict:
         """
         Create a new schedule.
         
@@ -58,6 +65,7 @@ class ScheduleService:
             social_network (str): Social account ID (as string)
             schedule_time (str): Schedule time in format "HH:MM"
             days (List[str]): List of days to schedule
+            timezone (str): User's timezone (optional)
             
         Returns:
             Dict: Created schedule
@@ -96,11 +104,15 @@ class ScheduleService:
             created_schedules = []
             
             for day in days:
-                # Format schedule time
+                # Format schedule time with timezone
                 formatted_schedule = f"{day} {schedule_time}"
                 
+                # Add timezone if provided
+                if timezone:
+                    formatted_schedule = format_timezone_schedule(formatted_schedule, timezone)
+                
                 # Calculate adjusted time (5 minutes before for content generation)
-                adjusted_time = self._calculate_adjusted_time(formatted_schedule)
+                adjusted_time = calculate_adjusted_time_with_timezone(formatted_schedule, timezone)
                 
                 # Insert schedule
                 response = (
@@ -169,6 +181,7 @@ class ScheduleService:
     def _calculate_adjusted_time(self, schedule_time: str) -> str:
         """
         Calculate adjusted time for content generation (5 minutes before schedule).
+        Legacy method - kept for backward compatibility.
         
         Args:
             schedule_time (str): Original schedule time

backend/utils/timezone_utils.py

@@ -0,0 +1,196 @@
+"""Timezone utility functions for the scheduling system."""
+
+import logging
+from datetime import datetime, time, timedelta
+from typing import Optional, Tuple, Dict, Any
+import pytz
+from zoneinfo import ZoneInfo
+from zoneinfo._common import ZoneInfoNotFoundError
+
+logger = logging.getLogger(__name__)
+
+# List of common IANA timezone names for validation
+COMMON_TIMEZONES = [
+    'UTC',
+    'America/New_York', 'America/Chicago', 'America/Denver', 'America/Los_Angeles',
+    'Europe/London', 'Europe/Paris', 'Europe/Berlin', 'Europe/Rome',
+    'Asia/Tokyo', 'Asia/Shanghai', 'Asia/Dubai', 'Asia/Kolkata',
+    'Australia/Sydney', 'Pacific/Auckland',
+    'Africa/Porto-Novo', 'Africa/Cairo', 'Africa/Johannesburg',
+    'America/Toronto', 'America/Mexico_City', 'America/Sao_Paulo',
+    'Europe/Madrid', 'Europe/Amsterdam', 'Europe/Stockholm',
+    'Asia/Seoul', 'Asia/Singapore', 'Asia/Hong_Kong',
+    'Pacific/Honolulu'
+]
+
+def validate_timezone(timezone_str: str) -> bool:
+    """
+    Validate if a timezone string is valid.
+    
+    Args:
+        timezone_str (str): Timezone string to validate
+        
+    Returns:
+        bool: True if valid, False otherwise
+    """
+    try:
+        ZoneInfo(timezone_str)
+        return True
+    except (pytz.UnknownTimeZoneError, ValueError, ZoneInfoNotFoundError):
+        return False
+
+def get_user_timezone() -> str:
+    """
+    Get the system's local timezone.
+    
+    Returns:
+        str: System timezone string
+    """
+    try:
+        # Get system timezone
+        import tzlocal
+        return str(tzlocal.get_localzone())
+    except Exception:
+        # Fallback to UTC
+        return 'UTC'
+
+def parse_timezone_schedule(schedule_time: str) -> Tuple[str, Optional[str]]:
+    """
+    Parse a timezone-prefixed schedule time string.
+    
+    Args:
+        schedule_time (str): Schedule time in format "Day HH:MM::::timezone" or "Day HH:MM"
+        
+    Returns:
+        Tuple[str, Optional[str]]: (time_part, timezone_part)
+    """
+    if "::::" in schedule_time:
+        time_part, timezone_part = schedule_time.split("::::", 1)
+        return time_part.strip(), timezone_part.strip()
+    else:
+        # Legacy format without timezone
+        return schedule_time, None
+
+def format_timezone_schedule(time_part: str, timezone: Optional[str]) -> str:
+    """
+    Format a schedule time with timezone prefix.
+    
+    Args:
+        time_part (str): Time part in format "Day HH:MM"
+        timezone (Optional[str]): Timezone string or None
+        
+    Returns:
+        str: Formatted schedule time with timezone
+    """
+    if timezone:
+        return f"{time_part}::::{timezone}"
+    else:
+        return time_part
+
+def convert_time_to_timezone(time_str: str, from_timezone: str, to_timezone: str) -> str:
+    """
+    Convert a time string from one timezone to another.
+    
+    Args:
+        time_str (str): Time string in format "Day HH:MM"
+        from_timezone (str): Source timezone
+        to_timezone (str): Target timezone
+        
+    Returns:
+        str: Converted time string in format "Day HH:MM"
+    """
+    try:
+        # Parse the time string
+        day_name, time_part = time_str.split()
+        hour, minute = map(int, time_part.split(':'))
+        
+        # Create timezone objects
+        from_tz = ZoneInfo(from_timezone)
+        to_tz = ZoneInfo(to_timezone)
+        
+        # Get current date to handle timezone conversion
+        now = datetime.now(from_tz)
+        
+        # Create datetime with the specified time
+        scheduled_datetime = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+        
+        # Convert to target timezone
+        target_datetime = scheduled_datetime.astimezone(to_tz)
+        
+        # Return in the same format
+        return f"{day_name} {target_datetime.hour:02d}:{target_datetime.minute:02d}"
+        
+    except Exception as e:
+        logger.error(f"Error converting time {time_str} from {from_timezone} to {to_timezone}: {str(e)}")
+        # Return original time as fallback
+        return time_str
+
+def get_server_timezone() -> str:
+    """
+    Get the server's timezone.
+    
+    Returns:
+        str: Server timezone string
+    """
+    try:
+        # Try to get from environment first
+        import os
+        server_tz = os.environ.get('TZ', 'UTC')
+        if validate_timezone(server_tz):
+            return server_tz
+        
+        # Fallback to system timezone
+        return get_user_timezone()
+    except Exception:
+        return 'UTC'
+
+def calculate_adjusted_time_with_timezone(schedule_time: str, timezone: str) -> str:
+    """
+    Calculate adjusted time for content generation (5 minutes before schedule) with timezone support.
+    
+    Args:
+        schedule_time (str): Schedule time in format "Day HH:MM::::timezone" or "Day HH:MM"
+        timezone (str): Timezone string
+        
+    Returns:
+        str: Adjusted time with timezone
+    """
+    try:
+        # Parse the schedule time
+        time_part, schedule_timezone = parse_timezone_schedule(schedule_time)
+        
+        # Use provided timezone or fallback to the one from schedule_time
+        effective_timezone = schedule_timezone or timezone
+        
+        if not effective_timezone:
+            effective_timezone = get_server_timezone()
+        
+        # Parse the time part
+        day, time_str = time_part.split()
+        hour, minute = map(int, time_str.split(':'))
+        
+        # Create timezone object
+        tz = ZoneInfo(effective_timezone)
+        
+        # Get current date in the timezone
+        now = datetime.now(tz)
+        
+        # Create scheduled datetime
+        scheduled_datetime = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+        
+        # Subtract 5 minutes for content generation
+        adjusted_datetime = scheduled_datetime - timedelta(minutes=5)
+        
+        # Format back to string
+        adjusted_time_str = f"{day} {adjusted_datetime.hour:02d}:{adjusted_datetime.minute:02d}"
+        
+        # Return with timezone only if effective_timezone is not None
+        if effective_timezone:
+            return format_timezone_schedule(adjusted_time_str, effective_timezone)
+        else:
+            return adjusted_time_str
+        
+    except Exception as e:
+        logger.error(f"Error calculating adjusted time for {schedule_time}: {str(e)}")
+        # Return original time as fallback
+        return schedule_time

frontend/src/pages/Schedule.jsx

@@ -7,6 +7,7 @@ import {
   clearError
 } from '../store/reducers/schedulesSlice';
 import { fetchAccounts } from '../store/reducers/accountsSlice';
+import { formatScheduleForDisplay } from '../utils/timezoneUtils';
 
 const Schedule = () => {
   const dispatch = useDispatch();
@@ -17,6 +18,7 @@ const Schedule = () => {
   const [scheduleTime, setScheduleTime] = useState('18:00');
   const [selectedDays, setSelectedDays] = useState([]);
   const [isCreating, setIsCreating] = useState(false);
+  const [userTimezone, setUserTimezone] = useState('');
   
   const daysOfWeek = [
     'Monday', 'Tuesday', 'Wednesday', 'Thursday',
@@ -24,6 +26,10 @@ const Schedule = () => {
   ];
   
   useEffect(() => {
+    // Detect user timezone
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    setUserTimezone(timezone);
+    
     dispatch(fetchSchedules());
     dispatch(fetchAccounts());
     dispatch(clearError());
@@ -64,7 +70,8 @@ const Schedule = () => {
       await dispatch(createSchedule({
         social_network: selectedAccount,  // Pass the account ID, not the social network name
         schedule_time: scheduleTime,
-        days: selectedDays
+        days: selectedDays,
+        timezone: userTimezone
       })).unwrap();
       
       // Reset form
@@ -428,7 +435,9 @@ const Schedule = () => {
                                 </div>
                                 <span className="text-xs sm:text-sm font-medium text-gray-600">Time</span>
                               </div>
-                              <span className="time-value text-lg sm:text-2xl font-bold text-gray-900">{schedule.schedule_time}</span>
+                              <span className="time-value text-lg sm:text-2xl font-bold text-gray-900">
+                                {formatScheduleForDisplay(schedule.schedule_time)}
+                              </span>
                             </div>
                             
                             <div className="schedule-account">

frontend/src/services/scheduleService.js

@@ -28,14 +28,19 @@ class ScheduleService {
    * @param {string} scheduleData.social_network - Social account ID
    * @param {string} scheduleData.schedule_time - Schedule time in format "HH:MM"
    * @param {Array<string>} scheduleData.days - List of days to schedule
+   * @param {string} scheduleData.timezone - User's timezone (optional)
    * @returns {Promise} Promise that resolves to the create schedule response
    */
   async create(scheduleData) {
     try {
+      // Get user timezone if not provided
+      const timezone = scheduleData.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+      
       const response = await apiClient.post('/schedules', {
         social_network: scheduleData.social_network,
         schedule_time: scheduleData.schedule_time,
-        days: scheduleData.days
+        days: scheduleData.days,
+        timezone: timezone
       });
       
       if (import.meta.env.VITE_NODE_ENV === 'development') {

frontend/src/utils/timezoneUtils.js

@@ -0,0 +1,74 @@
+/**
+ * Timezone utility functions for the frontend scheduling system.
+ */
+
+/**
+ * Parse a timezone-prefixed schedule time string and extract the time part.
+ * @param {string} scheduleTime - Schedule time in format "Day HH:MM::::timezone" or "Day HH:MM"
+ * @returns {string} Time part without timezone
+ */
+export const parseScheduleTime = (scheduleTime) => {
+  if (!scheduleTime) return scheduleTime;
+  
+  if (scheduleTime.includes('::::')) {
+    return scheduleTime.split('::::')[0];
+  }
+  
+  // Legacy format without timezone
+  return scheduleTime;
+};
+
+/**
+ * Get the user's timezone from the browser.
+ * @returns {string} Timezone string (e.g., "America/New_York")
+ */
+export const getUserTimezone = () => {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch (error) {
+    console.error('Error getting timezone:', error);
+    return 'UTC'; // Fallback
+  }
+};
+
+/**
+ * Format a schedule time for display (day and time only, no timezone).
+ * @param {string} scheduleTime - Schedule time string
+ * @returns {string} Formatted time for display
+ */
+export const formatScheduleForDisplay = (scheduleTime) => {
+  const parsedTime = parseScheduleTime(scheduleTime);
+  if (!parsedTime) return '';
+  
+  // Split into day and time parts
+  const parts = parsedTime.trim().split(' ');
+  if (parts.length >= 2) {
+    const day = parts[0];
+    const time = parts[1];
+    return `${day} ${time}`;
+  }
+  
+  return parsedTime;
+};
+
+/**
+ * Check if a schedule time has timezone information.
+ * @param {string} scheduleTime - Schedule time string
+ * @returns {boolean} True if timezone is included
+ */
+export const hasTimezone = (scheduleTime) => {
+  return scheduleTime && scheduleTime.includes('::::');
+};
+
+/**
+ * Extract timezone from a schedule time string.
+ * @param {string} scheduleTime - Schedule time string
+ * @returns {string|null} Timezone string or null if not present
+ */
+export const extractTimezone = (scheduleTime) => {
+  if (!scheduleTime || !scheduleTime.includes('::::')) {
+    return null;
+  }
+  
+  return scheduleTime.split('::::')[1]?.trim() || null;
+};

simple_timezone_test.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""
+Simple test script to verify timezone functionality in the scheduling system.
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), 'backend'))
+
+from backend.utils.timezone_utils import (
+    validate_timezone,
+    format_timezone_schedule,
+    parse_timezone_schedule,
+    calculate_adjusted_time_with_timezone,
+    get_server_timezone
+)
+
+def test_timezone_validation():
+    """Test timezone validation functionality."""
+    print("Testing timezone validation...")
+    
+    # Valid timezones
+    valid_timezones = [
+        "UTC",
+        "America/New_York", 
+        "Europe/London",
+        "Asia/Tokyo",
+        "Africa/Porto-Novo"
+    ]
+    
+    for tz in valid_timezones:
+        assert validate_timezone(tz), f"Should validate {tz}"
+        print(f"[OK] {tz} - Valid")
+    
+    # Invalid timezones
+    invalid_timezones = [
+        "Invalid/Timezone",
+        "America/Bogus",
+        "Not/A_Timezone",
+        ""
+    ]
+    
+    for tz in invalid_timezones:
+        assert not validate_timezone(tz), f"Should invalidate {tz}"
+        print(f"[FAIL] {tz} - Invalid (as expected)")
+    
+    print("[OK] Timezone validation tests passed!\n")
+
+def test_timezone_formatting():
+    """Test timezone formatting functionality."""
+    print("Testing timezone formatting...")
+    
+    # Test formatting with timezone
+    schedule_time = "Monday 14:30"
+    timezone = "America/New_York"
+    formatted = format_timezone_schedule(schedule_time, timezone)
+    expected = "Monday 14:30::::America/New_York"
+    
+    assert formatted == expected, f"Expected '{expected}', got '{formatted}'"
+    print(f"[OK] Formatted: {formatted}")
+    
+    # Test formatting without timezone
+    formatted_no_tz = format_timezone_schedule(schedule_time, None)
+    assert formatted_no_tz == schedule_time, f"Expected '{schedule_time}', got '{formatted_no_tz}'"
+    print(f"[OK] No timezone: {formatted_no_tz}")
+    
+    print("[OK] Timezone formatting tests passed!\n")
+
+def test_timezone_parsing():
+    """Test timezone parsing functionality."""
+    print("Testing timezone parsing...")
+    
+    # Test parsing with timezone
+    schedule_with_tz = "Monday 14:30::::America/New_York"
+    time_part, tz_part = parse_timezone_schedule(schedule_with_tz)
+    
+    assert time_part == "Monday 14:30", f"Expected 'Monday 14:30', got '{time_part}'"
+    assert tz_part == "America/New_York", f"Expected 'America/New_York', got '{tz_part}'"
+    print(f"[OK] Parsed time: {time_part}, timezone: {tz_part}")
+    
+    # Test parsing without timezone
+    schedule_without_tz = "Monday 14:30"
+    time_part_no_tz, tz_part_no_tz = parse_timezone_schedule(schedule_without_tz)
+    
+    assert time_part_no_tz == "Monday 14:30", f"Expected 'Monday 14:30', got '{time_part_no_tz}'"
+    assert tz_part_no_tz is None, f"Expected None, got '{tz_part_no_tz}'"
+    print(f"[OK] Parsed time: {time_part_no_tz}, timezone: {tz_part_no_tz}")
+    
+    print("[OK] Timezone parsing tests passed!\n")
+
+def test_adjusted_time_calculation():
+    """Test adjusted time calculation with timezone."""
+    print("Testing adjusted time calculation...")
+    
+    # Test with timezone
+    schedule_time = "Monday 14:30::::America/New_York"
+    adjusted_time = calculate_adjusted_time_with_timezone(schedule_time, "America/New_York")
+    expected = "Monday 14:25::::America/New_York"
+    
+    assert adjusted_time == expected, f"Expected '{expected}', got '{adjusted_time}'"
+    print(f"[OK] Adjusted with timezone: {adjusted_time}")
+    
+    # Test without timezone
+    schedule_time_no_tz = "Monday 14:30"
+    adjusted_time_no_tz = calculate_adjusted_time_with_timezone(schedule_time_no_tz, None)
+    expected_no_tz = "Monday 14:25"
+    
+    assert adjusted_time_no_tz == expected_no_tz, f"Expected '{expected_no_tz}', got '{adjusted_time_no_tz}'"
+    print(f"[OK] Adjusted without timezone: {adjusted_time_no_tz}")
+    
+    print("[OK] Adjusted time calculation tests passed!\n")
+
+def test_server_timezone():
+    """Test server timezone detection."""
+    print("Testing server timezone detection...")
+    
+    server_tz = get_server_timezone()
+    print(f"[OK] Server timezone: {server_tz}")
+    
+    # Should be a valid timezone
+    assert validate_timezone(server_tz), f"Server timezone {server_tz} should be valid"
+    print("[OK] Server timezone is valid!")
+    
+    print("[OK] Server timezone tests passed!\n")
+
+def test_frontend_compatibility():
+    """Test frontend compatibility with timezone data."""
+    print("Testing frontend compatibility...")
+    
+    # Simulate data that would come from the database
+    schedule_data = {
+        "id": "123",
+        "schedule_time": "Monday 14:30::::America/New_York",
+        "adjusted_time": "Monday 14:25::::America/New_York"
+    }
+    
+    # Test parsing like the frontend would do
+    display_time = schedule_data["schedule_time"].split("::::")[0]
+    print(f"[OK] Display time (no timezone): {display_time}")
+    
+    # Test that timezone can be extracted
+    if "::::" in schedule_data["schedule_time"]:
+        timezone = schedule_data["schedule_time"].split("::::")[1]
+        print(f"[OK] Extracted timezone: {timezone}")
+    
+    print("[OK] Frontend compatibility tests passed!\n")
+
+def main():
+    """Run all timezone tests."""
+    print("Starting timezone functionality tests...\n")
+    
+    try:
+        test_timezone_validation()
+        test_timezone_formatting()
+        test_timezone_parsing()
+        test_adjusted_time_calculation()
+        test_server_timezone()
+        test_frontend_compatibility()
+        
+        print("[OK] All timezone tests passed successfully!")
+        return True
+        
+    except Exception as e:
+        print(f"[FAIL] Test failed with error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

test_timezone_functionality.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""
+Test script to verify timezone functionality in the scheduling system.
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), 'backend'))
+
+from backend.utils.timezone_utils import (
+    validate_timezone,
+    format_timezone_schedule,
+    parse_timezone_schedule,
+    calculate_adjusted_time_with_timezone,
+    get_server_timezone,
+    convert_time_to_timezone
+)
+
+def test_timezone_validation():
+    """Test timezone validation functionality."""
+    print("🧪 Testing timezone validation...")
+    
+    # Valid timezones
+    valid_timezones = [
+        "UTC",
+        "America/New_York", 
+        "Europe/London",
+        "Asia/Tokyo",
+        "Africa/Porto-Novo"
+    ]
+    
+    for tz in valid_timezones:
+        assert validate_timezone(tz), f"Should validate {tz}"
+        print(f"✅ {tz} - Valid")
+    
+    # Invalid timezones
+    invalid_timezones = [
+        "Invalid/Timezone",
+        "America/Bogus",
+        "Not/A_Timezone",
+        ""
+    ]
+    
+    for tz in invalid_timezones:
+        assert not validate_timezone(tz), f"Should invalidate {tz}"
+        print(f"❌ {tz} - Invalid (as expected)")
+    
+    print("✅ Timezone validation tests passed!\n")
+
+def test_timezone_formatting():
+    """Test timezone formatting functionality."""
+    print("🧪 Testing timezone formatting...")
+    
+    # Test formatting with timezone
+    schedule_time = "Monday 14:30"
+    timezone = "America/New_York"
+    formatted = format_timezone_schedule(schedule_time, timezone)
+    expected = "Monday 14:30::::America/New_York"
+    
+    assert formatted == expected, f"Expected '{expected}', got '{formatted}'"
+    print(f"✅ Formatted: {formatted}")
+    
+    # Test formatting without timezone
+    formatted_no_tz = format_timezone_schedule(schedule_time, None)
+    assert formatted_no_tz == schedule_time, f"Expected '{schedule_time}', got '{formatted_no_tz}'"
+    print(f"✅ No timezone: {formatted_no_tz}")
+    
+    print("✅ Timezone formatting tests passed!\n")
+
+def test_timezone_parsing():
+    """Test timezone parsing functionality."""
+    print("🧪 Testing timezone parsing...")
+    
+    # Test parsing with timezone
+    schedule_with_tz = "Monday 14:30::::America/New_York"
+    time_part, tz_part = parse_timezone_schedule(schedule_with_tz)
+    
+    assert time_part == "Monday 14:30", f"Expected 'Monday 14:30', got '{time_part}'"
+    assert tz_part == "America/New_York", f"Expected 'America/New_York', got '{tz_part}'"
+    print(f"✅ Parsed time: {time_part}, timezone: {tz_part}")
+    
+    # Test parsing without timezone
+    schedule_without_tz = "Monday 14:30"
+    time_part_no_tz, tz_part_no_tz = parse_timezone_schedule(schedule_without_tz)
+    
+    assert time_part_no_tz == "Monday 14:30", f"Expected 'Monday 14:30', got '{time_part_no_tz}'"
+    assert tz_part_no_tz is None, f"Expected None, got '{tz_part_no_tz}'"
+    print(f"✅ Parsed time: {time_part_no_tz}, timezone: {tz_part_no_tz}")
+    
+    print("✅ Timezone parsing tests passed!\n")
+
+def test_adjusted_time_calculation():
+    """Test adjusted time calculation with timezone."""
+    print("🧪 Testing adjusted time calculation...")
+    
+    # Test with timezone
+    schedule_time = "Monday 14:30::::America/New_York"
+    adjusted_time = calculate_adjusted_time_with_timezone(schedule_time, "America/New_York")
+    expected = "Monday 14:25::::America/New_York"
+    
+    assert adjusted_time == expected, f"Expected '{expected}', got '{adjusted_time}'"
+    print(f"✅ Adjusted with timezone: {adjusted_time}")
+    
+    # Test without timezone
+    schedule_time_no_tz = "Monday 14:30"
+    adjusted_time_no_tz = calculate_adjusted_time_with_timezone(schedule_time_no_tz, None)
+    expected_no_tz = "Monday 14:25"
+    
+    assert adjusted_time_no_tz == expected_no_tz, f"Expected '{expected_no_tz}', got '{adjusted_time_no_tz}'"
+    print(f"✅ Adjusted without timezone: {adjusted_time_no_tz}")
+    
+    print("✅ Adjusted time calculation tests passed!\n")
+
+def test_server_timezone():
+    """Test server timezone detection."""
+    print("🧪 Testing server timezone detection...")
+    
+    server_tz = get_server_timezone()
+    print(f"✅ Server timezone: {server_tz}")
+    
+    # Should be a valid timezone
+    assert validate_timezone(server_tz), f"Server timezone {server_tz} should be valid"
+    print("✅ Server timezone is valid!")
+    
+    print("✅ Server timezone tests passed!\n")
+
+def test_time_conversion():
+    """Test time conversion between timezones."""
+    print("🧪 Testing time conversion...")
+    
+    # Test conversion from one timezone to another
+    from_tz = "America/New_York"
+    to_tz = "Europe/London"
+    time_str = "Monday 14:30"
+    
+    try:
+        converted_time = convert_time_to_timezone(time_str, from_tz, to_tz)
+        print(f"✅ Converted {time_str} from {from_tz} to {to_tz}: {converted_time}")
+    except Exception as e:
+        print(f"⚠️ Time conversion failed (expected if pytz not available): {e}")
+    
+    print("✅ Time conversion tests completed!\n")
+
+def test_frontend_compatibility():
+    """Test frontend compatibility with timezone data."""
+    print("🧪 Testing frontend compatibility...")
+    
+    # Simulate data that would come from the database
+    schedule_data = {
+        "id": "123",
+        "schedule_time": "Monday 14:30::::America/New_York",
+        "adjusted_time": "Monday 14:25::::America/New_York"
+    }
+    
+    # Test parsing like the frontend would do
+    display_time = schedule_data["schedule_time"].split("::::")[0]
+    print(f"✅ Display time (no timezone): {display_time}")
+    
+    # Test that timezone can be extracted
+    if "::::" in schedule_data["schedule_time"]:
+        timezone = schedule_data["schedule_time"].split("::::")[1]
+        print(f"✅ Extracted timezone: {timezone}")
+    
+    print("✅ Frontend compatibility tests passed!\n")
+
+def main():
+    """Run all timezone tests."""
+    print("Starting timezone functionality tests...\n")
+    
+    try:
+        test_timezone_validation()
+        test_timezone_formatting()
+        test_timezone_parsing()
+        test_adjusted_time_calculation()
+        test_server_timezone()
+        test_time_conversion()
+        test_frontend_compatibility()
+        
+        print("[OK] All timezone tests passed successfully!")
+        return True
+        
+    except Exception as e:
+        print(f"[FAIL] Test failed with error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)