Update routes/stylist.py

routes/stylist.py

@@ -381,12 +381,82 @@ def get_monthly_likes(user_id: str) -> Dict[str, Any]:
     start_date = (now_ny - relativedelta(months=6)).strftime('%Y-%m-%d')
     
     def parse_datetime_safely(date_str: str) -> datetime:
-        """Parse datetime string safely, handling microseconds overflow"""
+        """Parse datetime string safely, handling microseconds overflow and timezone formats"""
         try:
+            original_date_str = date_str
+            
             # Remove 'Z' e substitui por '+00:00' se necessário
             if date_str.endswith('Z'):
                 date_str = date_str.replace('Z', '+00:00')
             
+            # Normalizar timezone de -04 para -04:00
+            import re
+            tz_pattern = r'([+-])(\d{2})
+    
+    try:
+        # Primeiro, obter todos os feed_items do usuário
+        feeds_url = f"{SUPABASE_URL}/rest/v1/Feeds?user_id=eq.{user_id}"
+        feeds_response = requests.get(feeds_url, headers=SUPABASE_HEADERS)
+        
+        if feeds_response.status_code == 200:
+            feeds = feeds_response.json()
+            feed_ids = [feed.get("id") for feed in feeds]
+            
+            if feed_ids:
+                # Construir a condição para os feed_ids 
+                # (não podemos usar in.() diretamente por limitações da API, então vamos fazer uma string)
+                feed_ids_str = ','.join([str(id) for id in feed_ids])
+                
+                # Obter likes para esses feeds no intervalo de tempo
+                likes_url = f"{SUPABASE_URL}/rest/v1/likes?feed_item_id=in.({feed_ids_str})&created_at=gte.{start_date}"
+                likes_response = requests.get(likes_url, headers=SUPABASE_HEADERS)
+                
+                if likes_response.status_code == 200:
+                    likes = likes_response.json()
+                    logger.info(f"📊 Found {len(likes)} likes for user {user_id}")
+                    
+                    # Contar likes por mês
+                    for like in likes:
+                        # Converter a data para o fuso horário de NY usando o parse seguro
+                        like_date_str = like.get("created_at")
+                        if like_date_str:
+                            like_date = parse_datetime_safely(like_date_str).astimezone(ny_timezone)
+                            
+                            month_key = f"{like_date.year}-{like_date.month}"
+                            logger.debug(f"📅 Like date: {like_date_str} -> {like_date} -> month_key: {month_key}")
+                            
+                            if month_key in monthly_data:
+                                monthly_data[month_key]["likes_count"] += 1
+                                total_likes_last_6_months += 1
+                                logger.debug(f"✅ Added like to {month_key}, total now: {monthly_data[month_key]['likes_count']}")
+                            else:
+                                logger.debug(f"⚠️ Month key {month_key} not in range, skipping like from {like_date}")
+                else:
+                    logger.warning(f"⚠️ Failed to fetch likes: {likes_response.status_code}")
+            else:
+                logger.info(f"📭 No feed items found for user {user_id}")
+        else:
+            logger.warning(f"⚠️ Failed to fetch feeds: {feeds_response.status_code}")
+        
+        # Convertendo para lista e ordenando por mês (do mais recente para o mais antigo)
+        result = list(monthly_data.values())
+        result.sort(key=lambda x: (now_ny.year * 12 + now_ny.month - (x["month"])) % 12)
+        
+        return {
+            "monthly_likes": result,
+            "total_likes_last_6_months": total_likes_last_6_months
+        }
+    except Exception as e:
+        logger.error(f"❌ Error getting monthly likes: {str(e)}")
+        return {
+            "monthly_likes": list(monthly_data.values()),
+            "total_likes_last_6_months": 0
+        }
+            match = re.search(tz_pattern, date_str)
+            if match:
+                sign, hours = match.groups()
+                date_str = re.sub(tz_pattern, f'{sign}{hours}:00', date_str)
+            
             # Verificar se há microssegundos com mais de 6 dígitos
             if '.' in date_str:
                 # Separar a parte dos microssegundos
@@ -397,7 +467,7 @@ def get_monthly_likes(user_id: str) -> Dict[str, Any]:
                     
                     # Encontrar onde começa o timezone (+ ou - após os dígitos)
                     tz_start_idx = -1
-                    for i in range(1, len(microsec_and_tz)):  # Começar do índice 1 para evitar o sinal no início
+                    for i in range(len(microsec_and_tz)):
                         if microsec_and_tz[i] in ['+', '-']:
                             tz_start_idx = i
                             break
@@ -418,11 +488,26 @@ def get_monthly_likes(user_id: str) -> Dict[str, Any]:
                             microsec_and_tz = microsec_and_tz[:6]
                         date_str = f"{base_part}.{microsec_and_tz}"
             
-            return datetime.fromisoformat(date_str)
+            parsed_date = datetime.fromisoformat(date_str)
+            logger.debug(f"✅ Successfully parsed date '{original_date_str}' -> '{date_str}' -> {parsed_date}")
+            return parsed_date
+            
         except ValueError as e:
-            logger.warning(f"⚠️ Error parsing date '{date_str}': {str(e)}")
-            # Retornar data atual como fallback
-            return datetime.now(pytz.UTC)
+            logger.warning(f"⚠️ Error parsing date '{original_date_str}': {str(e)}")
+            # Tentar um parsing mais simples como fallback
+            try:
+                # Remover microssegundos completamente e tentar novamente
+                simple_date = original_date_str.split('.')[0]
+                # Adicionar timezone padrão se não tiver
+                if not any(tz in simple_date for tz in ['+', '-', 'Z']):
+                    simple_date += '-04:00'
+                elif simple_date.endswith('-04'):
+                    simple_date += ':00'
+                return datetime.fromisoformat(simple_date)
+            except:
+                logger.error(f"❌ Failed to parse date '{original_date_str}' with fallback method")
+                # Último recurso: retornar data atual
+                return datetime.now(pytz.UTC)
     
     try:
         # Primeiro, obter todos os feed_items do usuário