Update routes/stylist.py

routes/stylist.py

@@ -357,6 +357,76 @@ def get_courtesy_consultations(user_id: str) -> Dict[str, Any]:
             "monthly_courtesy_consultations": list(monthly_data.values())
         }
 
+def parse_datetime_safely(date_str: str) -> datetime:
+    """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})$'
+        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
+            parts = date_str.split('.')
+            if len(parts) == 2:
+                base_part = parts[0]
+                microsec_and_tz = parts[1]
+                
+                # Encontrar onde começa o timezone (+ ou - após os dígitos)
+                tz_start_idx = -1
+                for i in range(len(microsec_and_tz)):
+                    if microsec_and_tz[i] in ['+', '-']:
+                        tz_start_idx = i
+                        break
+                
+                if tz_start_idx > 0:
+                    # Há timezone
+                    microsec_part = microsec_and_tz[:tz_start_idx]
+                    tz_part = microsec_and_tz[tz_start_idx:]
+                    
+                    # Limitar microssegundos a 6 dígitos
+                    if len(microsec_part) > 6:
+                        microsec_part = microsec_part[:6]
+                    
+                    date_str = f"{base_part}.{microsec_part}{tz_part}"
+                else:
+                    # Não há timezone, apenas microssegundos
+                    if len(microsec_and_tz) > 6:
+                        microsec_and_tz = microsec_and_tz[:6]
+                    date_str = f"{base_part}.{microsec_and_tz}"
+        
+        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 '{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)
+
+
 def get_monthly_likes(user_id: str) -> Dict[str, Any]:
     ny_timezone = pytz.timezone('America/New_York')
     now_ny = datetime.now(ny_timezone)
@@ -380,19 +450,6 @@ def get_monthly_likes(user_id: str) -> Dict[str, Any]:
     # Calcular data de início (6 meses atrás)
     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 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}"
@@ -452,110 +509,6 @@ def get_monthly_likes(user_id: str) -> Dict[str, Any]:
             "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
-                parts = date_str.split('.')
-                if len(parts) == 2:
-                    base_part = parts[0]
-                    microsec_and_tz = parts[1]
-                    
-                    # Encontrar onde começa o timezone (+ ou - após os dígitos)
-                    tz_start_idx = -1
-                    for i in range(len(microsec_and_tz)):
-                        if microsec_and_tz[i] in ['+', '-']:
-                            tz_start_idx = i
-                            break
-                    
-                    if tz_start_idx > 0:
-                        # Há timezone
-                        microsec_part = microsec_and_tz[:tz_start_idx]
-                        tz_part = microsec_and_tz[tz_start_idx:]
-                        
-                        # Limitar microssegundos a 6 dígitos
-                        if len(microsec_part) > 6:
-                            microsec_part = microsec_part[:6]
-                        
-                        date_str = f"{base_part}.{microsec_part}{tz_part}"
-                    else:
-                        # Não há timezone, apenas microssegundos
-                        if len(microsec_and_tz) > 6:
-                            microsec_and_tz = microsec_and_tz[:6]
-                        date_str = f"{base_part}.{microsec_and_tz}"
-            
-            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 '{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
-        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()
-                    
-                    # 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}"
-                            if month_key in monthly_data:
-                                monthly_data[month_key]["likes_count"] += 1
-                                total_likes_last_6_months += 1
-        
-        # 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
-        }
         
 @router.post("/bank_account_dashboard_link")
 async def generate_bank_account_dashboard_link(data: UserIDRequest):