- fix upload-drive & notion

Project.py

@@ -81,17 +81,13 @@ class Project:
     'generated_plan_test_components': lambda self: self.generated_plan_test_components,
     'generated_page_dev_components': lambda self: self.generated_page_dev_components,
     'generated_engage_dev_components': lambda self: self.generated_engage_dev_components,
-    'reformatted_page_dev_components': lambda self: self.reformatted_dev_components,
-    'reformatted_engage_dev_components': lambda self: self.reformatted_dev_components,
-    'reformatted_hybrid_dev_components': lambda self: self.reformatted_dev_components,
+    'reformatted_dev_components': lambda self: self.reformatted_dev_components,
     'generated_intents_csv': lambda self: self.generated_intents_csv,
     'generated_plan_test_mandays': lambda self: self.generated_plan_test_mandays,
-    'reformatted_dev_components': lambda self: self.reformatted_dev_components,
     'generated_dev_mandays': lambda self: self.generated_dev_mandays,
-    'mvp_components': lambda self: self.mvp_components,
     'generated_mvp_prd': lambda self: self.generated_mvp_prd,
     'combined_cost_summary': lambda self: self.combined_cost_summary,
-    'generated_page_BD_SOW': lambda self: self.generated_BD_SOW,
+    'generated_BD_SOW': lambda self: self.generated_BD_SOW,
     'generated_Tech_SOW': lambda self: self.generated_Tech_SOW,
     'identified_planning_testing_components': lambda self: self.identified_planning_testing_components,
     'identified_development_components': lambda self: self.identified_development_components,

event_handler.py

@@ -134,6 +134,18 @@ def setup_all_handlers(step_buttons, all_components, progress_update, quotation_
             outputs=[quotation_cost],
         )
         
+        upload_drive_btn.click(
+            fn=upload_to_gdrive,
+            inputs=[project_name],
+            outputs=[progress_update]
+        )
+        
+        upload_notion_btn.click(
+            fn=upload_to_notion,
+            inputs=[project_name],
+            outputs=[progress_update]
+        )
+        
     except Exception as e:
         print(f"Error setting up handlers: {str(e)}")
         return None

google_drive.py

@@ -9,6 +9,10 @@ from google.oauth2 import service_account
 from googleapiclient.errors import HttpError
 from docx import Document
 import re
+from datetime import datetime
+import gradio as gr
+from state import state
+import json
 
 # Path to your Service Account key file
 SERVICE_ACCOUNT_FILE = 'gdrive_service_account.json'
@@ -131,61 +135,6 @@ def process_table(doc, table_rows):
                     run = paragraph.add_run(cell_content)
                     run.bold = is_bold
 
-def convert_md_to_docx(md_content):
-    """
-    Convert Markdown content to a DOCX document using python-docx.
-    Handles headings, lists, tables, and text formatting.
-    """
-    doc = Document()
-    lines = md_content.split('\n')
-    in_table = False
-    table_rows = []
-    line_index = 0
-    
-    while line_index < len(lines):
-        line = lines[line_index]
-        stripped_line = line.strip()
-        
-        # Handle tables
-        if stripped_line.startswith('|') and stripped_line.endswith('|'):
-            if not in_table:
-                in_table = True
-                table_rows = []  # Reset table rows when starting a new table
-            
-            table_rows.append(stripped_line)
-            line_index += 1
-            continue
-        
-        # Handle end of table
-        if in_table:
-            # Process the table when we hit non-table content
-            if table_rows:
-                process_table(doc, table_rows)
-                table_rows = []
-            in_table = False
-            
-            # Only add paragraph if we're not at an empty line
-            if not stripped_line:
-                doc.add_paragraph()
-        
-        # Handle non-table content
-        if stripped_line:
-            process_non_table_line(doc, stripped_line)
-        elif not in_table:  # Only add empty paragraph if we're not in a table
-            doc.add_paragraph()
-        
-        line_index += 1
-    
-    # Handle any remaining table at the end of the document
-    if in_table and table_rows:
-        process_table(doc, table_rows)
-    
-    # Convert to bytes
-    output = io.BytesIO()
-    doc.save(output)
-    output.seek(0)
-    return output.getvalue()
-
 def process_non_table_line(doc, stripped_line):
     """
     Process a non-table line of markdown text, handling various formatting options.
@@ -255,6 +204,61 @@ def convert_df_to_text(df):
     table = f"| {header} |\n|{separator}|\n" + "\n".join(rows)
     return table
 
+def convert_md_to_docx(md_content):
+    """
+    Convert Markdown content to a DOCX document using python-docx.
+    Handles headings, lists, tables, and text formatting.
+    """
+    doc = Document()
+    lines = md_content.split('\n')
+    in_table = False
+    table_rows = []
+    line_index = 0
+    
+    while line_index < len(lines):
+        line = lines[line_index]
+        stripped_line = line.strip()
+        
+        # Handle tables
+        if stripped_line.startswith('|') and stripped_line.endswith('|'):
+            if not in_table:
+                in_table = True
+                table_rows = []  # Reset table rows when starting a new table
+            
+            table_rows.append(stripped_line)
+            line_index += 1
+            continue
+        
+        # Handle end of table
+        if in_table:
+            # Process the table when we hit non-table content
+            if table_rows:
+                process_table(doc, table_rows)
+                table_rows = []
+            in_table = False
+            
+            # Only add paragraph if we're not at an empty line
+            if not stripped_line:
+                doc.add_paragraph()
+        
+        # Handle non-table content
+        if stripped_line:
+            process_non_table_line(doc, stripped_line)
+        elif not in_table:  # Only add empty paragraph if we're not in a table
+            doc.add_paragraph()
+        
+        line_index += 1
+    
+    # Handle any remaining table at the end of the document
+    if in_table and table_rows:
+        process_table(doc, table_rows)
+    
+    # Convert to bytes
+    output = io.BytesIO()
+    doc.save(output)
+    output.seek(0)
+    return output.getvalue()
+
 def determine_mime_type(filename):
     """Determine MIME type based on file extension for Google Drive conversion."""
     print(f"Determining MIME type for {filename}...")
@@ -326,13 +330,31 @@ def upload_content(service, folder_id, filename, content):
                     mimetype=mime_type,
                     resumable=True
                 )
-        else:
+        elif isinstance(content, bytes):
             # For binary content (already bytes)
             media = MediaIoBaseUpload(
                 io.BytesIO(content),
                 mimetype=mime_type,
                 resumable=True
             )
+        elif isinstance(content, dict):
+            # Convert dict to JSON string
+            json_content = json.dumps(content, indent=2)
+            media = MediaIoBaseUpload(
+                io.BytesIO(json_content.encode('utf-8')),
+                mimetype='application/json',
+                resumable=True
+            )
+        elif isinstance(content, list):
+            # Convert list to a string representation
+            list_content = "\n".join(str(item) for item in content)
+            media = MediaIoBaseUpload(
+                io.BytesIO(list_content.encode('utf-8')),
+                mimetype='text/plain',
+                resumable=True
+            )
+        else:
+            raise ValueError("Unsupported content type for upload.")
         
         print(f"Prepared media for upload: {media}")
         
@@ -346,4 +368,126 @@ def upload_content(service, folder_id, filename, content):
     except Exception as e:
         print(f"An error occurred while uploading {filename}: {e}")
         raise e
+    
+def upload_to_gdrive(project_name, progress=gr.Progress()):
+    print("Starting upload to Google Drive...")
+    service = authenticate_drive_service()
+    
+    project = state.quotation_project
+    if project is None:
+        print("Error: quotation_project is not set")
+    
+    parent_folder_id = DRIVE_FOLDER_ID
+    if not parent_folder_id:
+        return "Drive folder ID is not set."
+    
+    if not project_name:
+        project_name = "Final Quotation"
+        
+    folder_metadata = {
+        'name': f'{project_name}_{datetime.now().strftime("%y%m%d_%H%M%S")}',
+        'mimeType': 'application/vnd.google-apps.folder',
+        'parents': [parent_folder_id]
+    }
+    
+    subfolder = service.files().create(body=folder_metadata, fields='id').execute()
+    subfolder_id = subfolder.get('id')
+    print(f"Created subfolder with ID: {subfolder_id}")
+    progress(0.1, "Created subfolder and preparing files to upload.")
+    
+    try:
+        # Define the attributes to upload with appropriate file extensions
+        attributes_to_upload = {
+            "generated_prd": "PRD.md",
+            "generated_plan_test_components": "plan_test_components.md",
+            "generated_page_dev_components": "page_dev_components.md",
+            "generated_engage_dev_components": "engage_dev_components.md",
+            "generated_intent_list": "intent_list.md",
+            "reformatted_dev_components": "reformatted_dev_components.md",
+            "generated_mvp_prd": "MVP_prd.md",
+            "combined_cost_summary": "cost_summary.md",
+            "generated_BD_SOW": "BD_SOW.md",
+            "generated_Tech_SOW": "Tech_SOW.md"
+        }
+        
+        # Upload each attribute using the upload_content function
+        for attr, filename in attributes_to_upload.items():
+            try:
+                content = getattr(project, attr, None)
+                print(f"Uploading {attr} with filename {filename}...")
+                if content:
+                    # Convert list of dicts to DataFrame if necessary
+                    if isinstance(content, list) and all(isinstance(i, dict) for i in content):
+                        content = pd.DataFrame(content)
+                    print(f"Content for {filename}: {content}")
+                    upload_content(service, subfolder_id, filename, content)
+                    progress(0.1, f"Uploaded {filename}")
+                else:
+                    print(f"No content found for {attr}")
+            except Exception as e:
+                print(f"Failed to upload {filename}: {e}")
+                
+        # Handle the mandays csv results 
+        try:
+            if project.mandays_results:
+                for result in project.mandays_results:
+                    function_name = result['function_name']
+                    df = pd.DataFrame(result['result'])
+                    if not df.empty:
+                      csv_content = df.to_csv(index=False)
+                    upload_content(service, subfolder_id, f"{function_name}.csv", csv_content)
+                    progress(0.1, f"Uploaded {function_name}.csv")
+            
+            if project.mvp_mandays_results:
+                for result in project.mvp_mandays_results:
+                    function_name = result['function_name']
+                    result_data = result['result']
+
+                    # Check if result_data is a dictionary
+                    if isinstance(result_data, dict):
+                        for section_name, records in result_data.items():
+                            if isinstance(records, list):
+                                df = pd.DataFrame(records)
+                                if not df.empty:
+                                  csv_content = df.to_csv(index=False)
+
+                                # Upload the CSV content to Google Drive
+                                upload_content(service, subfolder_id, f"{function_name}_{section_name}.csv", csv_content)
+                                progress(0.1, f"Uploaded {function_name}_{section_name}.csv")
+                            else:
+                                print(f"Unexpected data format for {section_name} in {function_name}.")
+                    else:
+                        print(f"Unexpected result data format for {function_name}.")
+        
+        except Exception as e:
+            print(f"Failed to upload mandays results: {e}")
+        
+        folder_url = f"https://drive.google.com/drive/folders/{subfolder_id}"
+        progress(1.0, "Upload complete")
+        return f"All files uploaded successfully. Folder URL: {folder_url}"
+    
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return f"Failed to upload files. Error: {e}"
 
+def upload_combined_content(service, subfolder_id, combined_cost_summary, generated_plan_test_components, reformatted_dev_components, generated_intent_list):
+    """
+    Combine various content sections into a single Markdown document and upload it.
+    """
+    # Combine the content into a single Markdown string
+    combined_content = f"""
+    # Final Cost Summary
+    {combined_cost_summary}
+    
+    # Final Planning and Testing Component
+    {generated_plan_test_components}
+    
+    # Final Development Component
+    {reformatted_dev_components}
+    
+    # Final Intent List 
+    {generated_intent_list}
+    """
+    
+    # Upload the combined content as a Markdown file
+    upload_content(service, subfolder_id, "quotation_document.md", combined_content)

notion.py

@@ -3,6 +3,8 @@ import re
 from notion_client import Client
 from datetime import datetime
 from dotenv import load_dotenv
+from state import state 
+import pandas as pd
 
 load_dotenv()
 
@@ -198,8 +200,10 @@ def upload_blocks_to_notion(notion, page_id, blocks, chunk_size=95):
         notion.blocks.children.append(page_id, children=chunk)
         print(f"Uploaded blocks {i+1} to {i+len(chunk)}")
 
-def upload_to_notion(project_name, generation_result):
+def upload_to_notion(project_name):
     """Upload generation results to Notion as subpages."""
+    
+    project = state.quotation_project
     try:
         notion = Client(auth=os.getenv("NOTION_TOKEN"))
         parent_page_id = os.getenv("NOTION_PAGE_ID")
@@ -216,33 +220,94 @@ def upload_to_notion(project_name, generation_result):
         parent_page_id = parent_page["id"]
         print(f"Created parent Notion page with ID: {parent_page_id}")
         
-        # Create subpages for each item
-        for item in generation_result:
-            if not (isinstance(item, (list, tuple)) and len(item) == 2):
-                print(f"Skipping invalid item: {item}")
+        # Define the attributes to upload
+        attributes_to_upload = [
+            "generated_prd",
+            "generated_plan_test_components",
+            "generated_page_dev_components",
+            "generated_engage_dev_components",
+            "generated_intent_list",
+            "reformatted_dev_components",
+            "generated_mvp_prd",
+            "combined_cost_summary",
+            "generated_BD_SOW",
+            "generated_Tech_SOW"
+        ]
+        
+        # Iterate over selected attributes of the project
+        for attr_name in attributes_to_upload:
+            if not hasattr(project, attr_name):
                 continue
-                
-            key, content = item
-            if not isinstance(key, str):
-                print(f"Skipping item with non-string key: {key}")
+            
+            content = getattr(project, attr_name)
+            if content is None:
                 continue
-                
-            print(f"Creating subpage for item '{key}'")
+            
+            print(f"Creating subpage for attribute '{attr_name}'")
             try:
                 # Create subpage
                 subpage = notion.pages.create(
                     parent={"page_id": parent_page_id},
-                    properties={"title": [{"type": "text", "text": {"content": key}}]}
+                    properties={"title": [{"type": "text", "text": {"content": attr_name}}]}
                 )
                 
                 # Process content
+                if isinstance(content, pd.DataFrame):
+                    content = content.to_markdown()
+                elif isinstance(content, list) and all(isinstance(i, dict) for i in content):
+                    # Convert list of dictionaries to DataFrame
+                    content = pd.DataFrame(content).to_markdown()
+                elif isinstance(content, list):
+                    # Convert list to a string representation
+                    content = "\n".join(str(item) for item in content)
+                
                 blocks = process_mixed_content(content) or markdown_to_notion_blocks(content)
                 if blocks:
                     upload_blocks_to_notion(notion, subpage["id"], blocks)
                 else:
-                    print(f"No blocks generated for subpage '{key}'")
+                    print(f"No blocks generated for subpage '{attr_name}'")
             except Exception as e:
-                print(f"Error processing item '{key}': {e}")
+                print(f"Error processing attribute '{attr_name}': {e}")
+        
+        # Upload mandays results
+        try:
+            if project.mandays_results:
+                for result in project.mandays_results:
+                    function_name = result['function_name']
+                    df = pd.DataFrame(result['result'])
+                    if not df.empty:
+                      markdown_content = df.to_markdown(index=False)
+                      blocks = markdown_to_notion_blocks(markdown_content)
+                    subpage = notion.pages.create(
+                        parent={"page_id": parent_page_id},
+                        properties={"title": [{"type": "text", "text": {"content": f"{function_name}_mandays"}}]}
+                    )
+                    upload_blocks_to_notion(notion, subpage["id"], blocks)
+                    print(f"Uploaded {function_name}_mandays to Notion")
+            
+            if project.mvp_mandays_results:
+                for result in project.mvp_mandays_results:
+                    function_name = result['function_name']
+                    result_data = result['result']
+                    
+                    df = pd.DataFrame(result_data)
+                    if isinstance(result_data, dict):
+                        for section_name, records in result_data.items():
+                            if isinstance(records, list):
+                                df = pd.DataFrame(records)
+                                if not df.empty:
+                                  markdown_content = df.to_markdown(index=False)  # Convert DataFrame to markdown
+                                  blocks = markdown_to_notion_blocks(markdown_content)
+                    
+                    subpage = notion.pages.create(
+                        parent={"page_id": parent_page_id},
+                        properties={"title": [{"type": "text", "text": {"content": f"{function_name}_mvp_mandays"}}]}
+                    )
+                    upload_blocks_to_notion(notion, subpage["id"], blocks)
+                    print(f"Uploaded {function_name}_mvp_mandays to Notion")
+        
+        except Exception as e:
+            print(f"Failed to upload mandays results to Notion: {e}")
         
         return f"Successfully uploaded to Notion page: {page_title}. Link: https://www.notion.so/{parent_page_id}"