quick fix timestamp

app/sheets.py

@@ -1,25 +1,44 @@
-from typing import Any, Dict, List, Optional
-from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import InstalledAppFlow
-from google.auth.transport.requests import Request
-from googleapiclient.discovery import build
 import os
 import pickle
-from datetime import datetime
-from loguru import logger
 import json
 import hashlib
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
 from google.oauth2.service_account import Credentials
+from google.auth.transport.requests import Request
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from loguru import logger
 
 from .utils import timing_decorator_sync
 from .constants import SHEET_RANGE
 
 SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
 
-def generate_conversation_id(user_id: str, page_id: str, timestamp: str) -> str:
+def generate_conversation_id(user_id: str, page_id: str, timestamp: Any) -> str:
+    """Tạo ID hội thoại duy nhất."""
     hash_input = f"{user_id}:{page_id}:{timestamp}"
     return hashlib.sha256(hash_input.encode()).hexdigest()[:32]
 
+def _flatten_and_unique_timestamps(items: List[Any]) -> List[Any]:
+    """
+    Hàm tiện ích để làm phẳng danh sách timestamp và loại bỏ các giá trị trùng lặp.
+    Xử lý được cả list lồng nhau.
+    """
+    flat_list = []
+    if not isinstance(items, list):
+        return [items]
+        
+    for item in items:
+        if isinstance(item, list):
+            flat_list.extend(_flatten_and_unique_timestamps(item))
+        else:
+            flat_list.append(item)
+    # Dùng dict để giữ lại thứ tự và loại bỏ trùng lặp
+    return list(dict.fromkeys(flat_list))
+
+
 class SheetsClient:
     def __init__(self, credentials_file: str, token_file: str, sheet_id: str):
         self.credentials_file = credentials_file
@@ -30,21 +49,20 @@ class SheetsClient:
 
     @timing_decorator_sync
     def authenticate(self) -> None:
+        """Xác thực với Google Sheets API."""
         credentials_json = os.getenv("GOOGLE_SHEETS_CREDENTIALS_JSON")
         if credentials_json:
             info = json.loads(credentials_json)
-            creds = Credentials.from_service_account_info(info, scopes=SCOPES)
-            self.creds = creds
+            self.creds = Credentials.from_service_account_info(info, scopes=SCOPES)
         else:
             if os.path.exists(self.token_file):
                 with open(self.token_file, 'rb') as token:
                     self.creds = pickle.load(token)
             if not self.creds or not self.creds.valid:
-                if self.creds and self.creds.expired:
+                if self.creds and self.creds.expired and self.creds.refresh_token:
                     self.creds.refresh(Request())
                 else:
-                    flow = InstalledAppFlow.from_client_secrets_file(
-                        self.credentials_file, SCOPES)
+                    flow = InstalledAppFlow.from_client_secrets_file(self.credentials_file, SCOPES)
                     self.creds = flow.run_local_server(port=0)
                 with open(self.token_file, 'wb') as token:
                     pickle.dump(self.creds, token)
@@ -52,158 +70,118 @@ class SheetsClient:
 
     @timing_decorator_sync
     def get_conversation_history(self, user_id: str, page_id: str) -> List[Dict[str, Any]]:
+        """Lấy lịch sử hội thoại từ sheet, xử lý timestamp một cách an toàn."""
         try:
             if not self.service:
                 self.authenticate()
-            range_name = SHEET_RANGE
+            
             result = self.service.spreadsheets().values().get(
                 spreadsheetId=self.sheet_id,
-                range=range_name
+                range=SHEET_RANGE
             ).execute()
             values = result.get('values', [])
+            if not values:
+                return []
+
+            header = values[0]
             history = []
-            for row in values:
-                row = row + [""] * (14 - len(row))
-                try:
-                    timestamps = json.loads(row[12]) if row[12] else []
-                    if not isinstance(timestamps, list):
-                        timestamps = [str(timestamps)]
-                except Exception:
-                    timestamps = []
-                if row[4] == user_id and row[5] == page_id:
-                    history.append({
-                        'conversation_id': row[0],
-                        'originalcommand': row[1],
-                        'originalcontent': row[2],
-                        'originalattachments': json.loads(row[3]) if row[3] else [],
-                        'recipient_id': row[4],
-                        'page_id': row[5],
-                        'originaltext': row[6],
-                        'originalvehicle': row[7],
-                        'originalaction': row[8],
-                        'originalpurpose': row[9],
-                        'originalquestion': row[10],
-                        'systemresponse': row[11],
-                        'timestamp': timestamps,
-                        'isdone': row[13].lower() == 'true'
-                    })
+            for row in values[1:]: # Bỏ qua dòng header
+                # Đảm bảo row có đủ cột
+                row_data = dict(zip(header, row + [""] * (len(header) - len(row))))
+                
+                if row_data.get('recipient_id') == user_id and row_data.get('page_id') == page_id:
+                    # Cải tiến: Xử lý an toàn việc đọc timestamp
+                    try:
+                        timestamps_raw = json.loads(row_data.get('timestamp', '[]'))
+                        timestamps = _flatten_and_unique_timestamps(timestamps_raw)
+                    except (json.JSONDecodeError, TypeError):
+                        timestamps = []
+
+                    row_data['timestamp'] = timestamps
+                    row_data['originalattachments'] = json.loads(row_data.get('originalattachments', '[]'))
+                    row_data['isdone'] = str(row_data.get('isdone', 'false')).lower() == 'true'
+                    history.append(row_data)
             return history
         except Exception as e:
-            logger.error(f"Error getting conversation history: {e}")
+            logger.error(f"Lỗi khi lấy lịch sử hội thoại: {e}")
             return []
 
     @timing_decorator_sync
-    def log_conversation(
-        self,
-        conversation_id: str,
-        recipient_id: str,
-        page_id: str,
-        originaltext: str = "",
-        originalcommand: str = "",
-        originalcontent: str = "",
-        originalattachments: Optional[List[str]] = None,
-        originalvehicle: str = "",
-        originalaction: str = "",
-        originalpurpose: str = "",
-        originalquestion: str = "",
-        systemresponse: str = "",
-        timestamp: Optional[str] = None,
-        isdone: bool = False
-    ) -> Optional[Dict[str, Any]]:
+    def log_conversation(self, **kwargs: Any) -> Optional[Dict[str, Any]]:
+        """
+        Ghi lại hoặc cập nhật một hội thoại.
+        - Nếu có 'conversation_id', sẽ tìm và CẬP NHẬT dòng đó.
+        - Nếu không, sẽ THÊM MỚI một dòng.
+        """
         try:
             if not self.service:
                 self.authenticate()
 
-            result = self.service.spreadsheets().values().get(
-                spreadsheetId=self.sheet_id,
-                range=SHEET_RANGE
-            ).execute()
-            values = result.get('values', [])
-
-            current_ts = timestamp or datetime.now().isoformat()
-            timestamps_list = [current_ts]
-
-            # Check duplicate
-            for row in values:
-                row = row + [""] * 14
-                try:
-                    row_timestamps = json.loads(row[12]) if row[12] else []
-                    if not isinstance(row_timestamps, list):
-                        row_timestamps = [row_timestamps]
-                except Exception:
-                    row_timestamps = []
-
-                row_recipient_id = row[4]
-                row_page_id = row[5]
-
-                if current_ts in [str(ts) for ts in row_timestamps] and \
-                   str(row_recipient_id) == str(recipient_id) and \
-                   str(row_page_id) == str(page_id):
-                    logger.info(f"Found duplicate conversation for user {recipient_id}, page {page_id}, timestamp {current_ts}")
-                    return {
-                        'conversation_id': row[0],
-                        'originalcommand': row[1],
-                        'originalcontent': row[2],
-                        'originalattachments': json.loads(row[3]) if row[3] else [],
-                        'recipient_id': row[4],
-                        'page_id': row[5],
-                        'originaltext': row[6],
-                        'originalvehicle': row[7],
-                        'originalaction': row[8],
-                        'originalpurpose': row[9],
-                        'originalquestion': row[10],
-                        'systemresponse': row[11],
-                        'timestamp': row_timestamps,
-                        'isdone': row[13].lower() == 'true' if len(row) > 13 else False
-                    }
-
-            conversation_id = generate_conversation_id(recipient_id, page_id, current_ts)
-            new_row = [
-                conversation_id,
-                originalcommand,
-                originalcontent,
-                json.dumps(originalattachments or []),
-                recipient_id,
-                page_id,
-                originaltext,
-                originalvehicle,
-                originalaction,
-                originalpurpose,
-                originalquestion,
-                systemresponse,
-                json.dumps(timestamps_list),
-                str(isdone).lower()
-            ]
-
-            body = {
-                'values': [new_row]
-            }
-
-            self.service.spreadsheets().values().append(
-                spreadsheetId=self.sheet_id,
-                range=SHEET_RANGE,
-                valueInputOption='RAW',
-                body=body
-            ).execute()
+            # Lấy toàn bộ dữ liệu từ sheet một lần
+            sheet = self.service.spreadsheets().values().get(spreadsheetId=self.sheet_id, range=SHEET_RANGE).execute()
+            values = sheet.get('values', [])
+            header = values[0] if values else []
+            if not header:
+                logger.error("Sheet rỗng hoặc không có header.")
+                return None
+
+            conversation_id = kwargs.get('conversation_id')
+            row_index_to_update = -1
+
+            # Tìm dòng cần cập nhật nếu có conversation_id
+            if conversation_id:
+                for i, row in enumerate(values[1:], start=2): # start=2 vì sheet index bắt đầu từ 1 và bỏ qua header
+                    if row and row[0] == conversation_id:
+                        row_index_to_update = i
+                        break
+
+            # Làm phẳng và đảm bảo timestamp là một list duy nhất
+            timestamps_list = _flatten_and_unique_timestamps(kwargs.get('timestamp', []))
+            kwargs['timestamp'] = timestamps_list # Cập nhật lại kwargs
+
+            # Chuẩn bị dữ liệu cho dòng mới/cập nhật
+            row_data = [str(kwargs.get(h, '')) for h in header]
+            # Chuyển đổi các trường đặc biệt sang JSON string
+            row_data[header.index('originalattachments')] = json.dumps(kwargs.get('originalattachments', []))
+            row_data[header.index('timestamp')] = json.dumps(timestamps_list)
+            row_data[header.index('isdone')] = str(kwargs.get('isdone', False)).lower()
+
+            if row_index_to_update != -1:
+                # --- CẬP NHẬT DÒNG HIỆN CÓ ---
+                logger.info(f"Đang cập nhật conversation: {conversation_id}")
+                range_to_update = f"A{row_index_to_update}"
+                body = {'values': [row_data]}
+                self.service.spreadsheets().values().update(
+                    spreadsheetId=self.sheet_id,
+                    range=range_to_update,
+                    valueInputOption='RAW',
+                    body=body
+                ).execute()
+            else:
+                # --- THÊM DÒNG MỚI ---
+                if not conversation_id:
+                    # Tạo ID mới nếu chưa có
+                    new_id = generate_conversation_id(
+                        kwargs.get('recipient_id', ''),
+                        kwargs.get('page_id', ''),
+                        timestamps_list[0] if timestamps_list else datetime.now().isoformat()
+                    )
+                    kwargs['conversation_id'] = new_id
+                    row_data[header.index('conversation_id')] = new_id
+                
+                logger.info(f"Đang thêm mới conversation: {kwargs['conversation_id']}")
+                body = {'values': [row_data]}
+                self.service.spreadsheets().values().append(
+                    spreadsheetId=self.sheet_id,
+                    range=SHEET_RANGE,
+                    valueInputOption='RAW',
+                    insertDataOption='INSERT_ROWS',
+                    body=body
+                ).execute()
+            
+            # Trả về dữ liệu đã được xử lý
+            return kwargs
 
-            logger.info(f"Thêm mới conversation: {conversation_id}")
-
-            return {
-                'conversation_id': conversation_id,
-                'originalcommand': originalcommand,
-                'originalcontent': originalcontent,
-                'originalattachments': originalattachments or [],
-                'recipient_id': recipient_id,
-                'page_id': page_id,
-                'originaltext': originaltext,
-                'originalvehicle': originalvehicle,
-                'originalaction': originalaction,
-                'originalpurpose': originalpurpose,
-                'originalquestion': originalquestion,
-                'systemresponse': systemresponse,
-                'timestamp': timestamps_list,
-                'isdone': isdone
-            }
         except Exception as e:
-            logger.error(f"Error logging conversation: {e}")
+            logger.error(f"Lỗi khi ghi/cập nhật conversation: {e}", exc_info=True)
             return None