update

backend/app/main.py

@@ -197,8 +197,61 @@ async def upload_asset(
                 user_id=1  # Default user - in production, get from session/auth
             )
             db.add(db_asset)
-            db.commit()
-            db.refresh(db_asset)
+            try:
+                db.commit()
+                try:
+                    db.refresh(db_asset)
+                except Exception as refresh_error:
+                    # Refresh might fail due to version string, but commit succeeded
+                    # Query the asset back to get the ID
+                    if "Could not determine version" in str(refresh_error):
+                        from sqlalchemy import text
+                        result = db.execute(
+                            text("SELECT id, created_at FROM assets WHERE name = :name AND file_path = :file_path ORDER BY id DESC LIMIT 1"),
+                            {"name": file.filename, "file_path": str(file_path)}
+                        )
+                        row = result.fetchone()
+                        if row:
+                            db_asset.id = row[0]
+                            # Set created_at if available
+                            if hasattr(db_asset, 'created_at') and row[1]:
+                                db_asset.created_at = row[1]
+                    else:
+                        raise refresh_error
+            except Exception as commit_error:
+                # If commit fails due to version string issue, try raw SQL
+                db.rollback()
+                error_str = str(commit_error)
+                if "Could not determine version" in error_str:
+                    # Try using raw SQL to insert
+                    from sqlalchemy import text
+                    try:
+                        result = db.execute(
+                            text("""
+                                INSERT INTO assets (name, file_path, file_type, product_category, sub_category, size, user_id, created_at)
+                                VALUES (:name, :file_path, :file_type, :product_category, :sub_category, :size, :user_id, NOW())
+                                RETURNING id, created_at
+                            """),
+                            {
+                                "name": file.filename,
+                                "file_path": str(file_path),
+                                "file_type": file_type,
+                                "product_category": product_category or "ocr",
+                                "sub_category": sub_category if sub_category and sub_category != "none" else None,
+                                "size": file_size,
+                                "user_id": 1
+                            }
+                        )
+                        row = result.fetchone()
+                        if row:
+                            db_asset.id = row[0]
+                            db_asset.created_at = row[1]
+                        db.commit()
+                    except Exception as sql_error:
+                        print(f"Raw SQL insert also failed: {sql_error}")
+                        raise commit_error
+                else:
+                    raise commit_error
             
             return {
                 "id": db_asset.id,
@@ -207,7 +260,7 @@ async def upload_asset(
                 "product_category": db_asset.product_category,
                 "sub_category": db_asset.sub_category,
                 "size": db_asset.size,
-                "created_at": db_asset.created_at.isoformat()
+                "created_at": db_asset.created_at.isoformat() if hasattr(db_asset, 'created_at') else datetime.utcnow().isoformat()
             }
         except Exception as db_error:
             # If database save fails, still return success (file is saved)
@@ -226,20 +279,112 @@ async def upload_asset(
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.get("/api/assets", response_model=List[AssetResponse])
-async def get_assets(product_category: Optional[str] = None):
+async def get_assets(
+    product_category: Optional[str] = None,
+    db: Session = Depends(get_db)
+):
     """Get list of assets"""
-    # Mock data for now
-    return [
-        {
-            "id": 1,
-            "name": "OCR_Demo_Screenshot.png",
-            "file_type": "image",
-            "product_category": "ocr",
-            "sub_category": None,
-            "size": 2516582,
-            "created_at": datetime.utcnow()
-        }
-    ]
+    try:
+        from app.models import Asset
+        from sqlalchemy import text
+        
+        # Try using ORM first
+        try:
+            query = db.query(Asset)
+            
+            if product_category and product_category != "all":
+                query = query.filter(Asset.product_category == product_category)
+            
+            db_assets = query.order_by(Asset.created_at.desc()).all()
+            
+            # Convert to response format
+            assets = []
+            for asset in db_assets:
+                assets.append({
+                    "id": asset.id,
+                    "name": asset.name,
+                    "file_type": asset.file_type,
+                    "product_category": asset.product_category,
+                    "sub_category": asset.sub_category,
+                    "size": asset.size,
+                    "created_at": asset.created_at
+                })
+        except Exception as orm_error:
+            # If ORM fails due to version string issue, use raw SQL
+            print(f"ORM query warning, using raw SQL: {orm_error}")
+            try:
+                sql_query = "SELECT id, name, file_path, file_type, product_category, sub_category, size, created_at FROM assets"
+                params = {}
+                if product_category and product_category != "all":
+                    sql_query += " WHERE product_category = :product_category"
+                    params["product_category"] = product_category
+                sql_query += " ORDER BY created_at DESC"
+                
+                result = db.execute(text(sql_query), params)
+                rows = result.fetchall()
+                
+                assets = []
+                for row in rows:
+                    assets.append({
+                        "id": row[0],
+                        "name": row[1],
+                        "file_type": row[3],
+                        "product_category": row[4],
+                        "sub_category": row[5],
+                        "size": row[6],
+                        "created_at": row[7]
+                    })
+            except Exception as sql_error:
+                print(f"Raw SQL query also failed: {sql_error}")
+                assets = []
+        
+        # Merge with mock data (as requested - keep dummy content)
+        mock_assets = [
+            {
+                "id": 9991,
+                "name": "OCR_Demo_Screenshot.png",
+                "file_type": "image",
+                "product_category": "ocr",
+                "sub_category": None,
+                "size": 2516582,
+                "created_at": datetime(2024, 12, 20)
+            },
+            {
+                "id": 9992,
+                "name": "P2P_Workflow_Diagram.pdf",
+                "file_type": "document",
+                "product_category": "p2p",
+                "sub_category": "Budget Approval Workflow",
+                "size": 1024000,
+                "created_at": datetime(2024, 12, 19)
+            },
+            {
+                "id": 9993,
+                "name": "O2C_Process_Video.mp4",
+                "file_type": "video",
+                "product_category": "o2c",
+                "sub_category": "Sales Order Workflow",
+                "size": 15728640,
+                "created_at": datetime(2024, 12, 18)
+            }
+        ]
+        
+        # Combine real assets with mock assets (real assets first)
+        return assets + mock_assets
+    except Exception as e:
+        # If database query fails, return mock data only
+        print(f"Database query warning: {e}")
+        return [
+            {
+                "id": 1,
+                "name": "OCR_Demo_Screenshot.png",
+                "file_type": "image",
+                "product_category": "ocr",
+                "sub_category": None,
+                "size": 2516582,
+                "created_at": datetime.utcnow()
+            }
+        ]
 
 # ---- Post Management ----
 

frontend/src/pages/Repository.jsx

@@ -1,4 +1,4 @@
-import React, { useState, useRef } from 'react';
+import React, { useState, useRef, useEffect } from 'react';
 import { motion, AnimatePresence } from 'framer-motion';
 import { 
   Upload, 
@@ -104,6 +104,8 @@ export default function Repository() {
   const [uploadProductCategory, setUploadProductCategory] = useState('');
   const [uploadSubCategory, setUploadSubCategory] = useState('');
   const [isUploading, setIsUploading] = useState(false);
+  const [assets, setAssets] = useState(mockAssets);
+  const [isLoadingAssets, setIsLoadingAssets] = useState(false);
   const fileInputRef = useRef(null);
 
   const toggleProduct = (productId) => {
@@ -114,14 +116,14 @@ export default function Repository() {
     );
   };
 
-  const filteredAssets = mockAssets.filter(asset => {
+  const filteredAssets = assets.filter(asset => {
     const matchesSearch = asset.name.toLowerCase().includes(searchQuery.toLowerCase());
     const matchesProduct = selectedProduct === 'all' || asset.product === selectedProduct;
     return matchesSearch && matchesProduct;
   });
 
   const getAssetsByProduct = (productId) => {
-    return mockAssets.filter(asset => asset.product === productId);
+    return assets.filter(asset => asset.product === productId);
   };
 
   const getTypeIcon = (type) => {
@@ -138,6 +140,57 @@ export default function Repository() {
     return product?.color || 'slate';
   };
 
+  // Fetch assets from API
+  const fetchAssets = async () => {
+    setIsLoadingAssets(true);
+    try {
+      const response = await fetch('/api/assets');
+      if (response.ok) {
+        const data = await response.json();
+        // Convert API response to match mockAssets format
+        const formattedAssets = data.map(asset => ({
+          id: asset.id,
+          name: asset.name,
+          type: asset.file_type,
+          product: asset.product_category,
+          subCategory: asset.sub_category,
+          size: formatFileSize(asset.size),
+          date: asset.created_at ? new Date(asset.created_at).toISOString().split('T')[0] : new Date().toISOString().split('T')[0]
+        }));
+        setAssets(formattedAssets);
+      } else {
+        console.error('Failed to fetch assets');
+        // Keep mockAssets on error
+      }
+    } catch (error) {
+      console.error('Error fetching assets:', error);
+      // Keep mockAssets on error
+    } finally {
+      setIsLoadingAssets(false);
+    }
+  };
+
+  // Format file size
+  const formatFileSize = (bytes) => {
+    if (!bytes) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
+  };
+
+  // Fetch assets on component mount and when upload dialog closes
+  useEffect(() => {
+    fetchAssets();
+  }, []);
+
+  // Refresh assets after successful upload
+  useEffect(() => {
+    if (!uploadDialogOpen && !isUploading) {
+      fetchAssets();
+    }
+  }, [uploadDialogOpen, isUploading]);
+
   const handleFileSelect = (files) => {
     const fileArray = Array.from(files);
     setSelectedFiles(fileArray);
@@ -202,8 +255,8 @@ export default function Repository() {
       // Show success message
       alert(`Successfully uploaded ${selectedFiles.length} file(s)!`);
       
-      // In a real app, you'd refresh the assets list here
-      // For now, the dummy content will still show
+      // Refresh assets list to show newly uploaded files
+      await fetchAssets();
     } catch (error) {
       console.error('Upload error:', error);
       alert(`Upload failed: ${error.message}`);