@marcos_feitoza/personal-finance-backen-trades-assets 1.0.3 → 1.0.4

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [1.0.4](https://github.com/MarcosOps/personal-finance-backend-trades-assets/compare/v1.0.3...v1.0.4) (2025-11-21)
+
+
+### Bug Fixes
+
+* update trades and assets to support current user ([7a976a5](https://github.com/MarcosOps/personal-finance-backend-trades-assets/commit/7a976a576eea4ab9758e5fa20d5b1d314ae72912))
+
 ## [1.0.3](https://github.com/MarcosOps/personal-finance-backend-trades-assets/compare/v1.0.2...v1.0.3) (2025-11-11)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@marcos_feitoza/personal-finance-backen-trades-assets",
-    "version": "1.0.3",
+    "version": "1.0.4",
     "publishConfig": {
         "access": "public"
     },

package/personal_finance_trades_assets/routers/assets.py

@@ -4,6 +4,8 @@ from sqlalchemy import distinct
 from personal_finance_shared import models, schemas
 from personal_finance_shared.database import get_db
 import logging
+from personal_finance_shared.dependencies import get_current_user
+
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -14,16 +16,23 @@ router = APIRouter(
 )
 
 @router.post("/", response_model=schemas.AssetResponse)
-def create_asset(asset: schemas.AssetCreate, db: Session = Depends(get_db)):
+def create_asset(
+    asset: schemas.AssetCreate, 
+    db: Session = Depends(get_db),
+    current_user: models.User = Depends(get_current_user) # Keep for authorization if needed
+):
+    # Assets are global now, check for symbol existence globally
     db_asset = db.query(models.Asset).filter(models.Asset.symbol == asset.symbol).first()
     if db_asset:
         raise HTTPException(status_code=400, detail="Asset with this symbol already exists")
+    
+    # user_id is removed from Asset model
     db_asset = models.Asset(
         symbol=asset.symbol,
         name=asset.name,
         asset_type=asset.asset_type,
         industry=asset.industry,
-        id_crypto=asset.id_crypto
+        id_crypto=asset.id_crypto,
     )
     db.add(db_asset)
     db.commit()
@@ -31,21 +40,26 @@ def create_asset(asset: schemas.AssetCreate, db: Session = Depends(get_db)):
     return db_asset
 
 @router.get("/", response_model=list[schemas.AssetResponse])
-def read_assets(investment_account: str = None, skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
-    logger.info(f"Reading assets for investment account: {investment_account}")
-    query = db.query(models.Asset)
+def read_assets(
+    investment_account: str = None, 
+    skip: int = 0, 
+    limit: int = 100, 
+    db: Session = Depends(get_db),
+    current_user: models.User = Depends(get_current_user)
+):
+    logger.info(f"Reading assets for user {current_user.id}, investment account: {investment_account}")
+    
+    # The query should join Trades and Assets to find assets owned by the user.
+    query = db.query(models.Asset).join(models.Trade).filter(
+        models.Trade.user_id == current_user.id
+    )
 
     if investment_account:
-        # Get asset_ids from trades for the given investment_account
-        asset_ids_in_account = db.query(distinct(models.Trade.asset_id)).filter(
-            models.Trade.investment_account == investment_account
-        ).all()
-        # Extract just the IDs from the list of tuples
-        asset_ids = [id for (id,) in asset_ids_in_account]
-        
-        # Filter assets by these IDs
-        query = query.filter(models.Asset.id.in_(asset_ids))
+        query = query.filter(models.Trade.investment_account == investment_account)
+
+    # Use distinct to avoid duplicate assets if a user traded the same asset multiple times
+    query = query.distinct()
 
     assets = query.offset(skip).limit(limit).all()
-    logger.info(f"Found {len(assets)} assets")
+    logger.info(f"Found {len(assets)} assets for user {current_user.id}")
     return assets

package/personal_finance_trades_assets/routers/trades.py

@@ -6,6 +6,8 @@ import logging
 import requests
 import os
 import httpx
+from personal_finance_shared.dependencies import get_current_user, get_current_token
+
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -31,56 +33,66 @@ def _get_asset_details_from_service(symbol: str) -> dict:
         return {}
 
 @router.post("/", response_model=schemas.TradeResponse)
-async def create_trade(trade: schemas.TradeCreate, db: Session = Depends(get_db)):
+async def create_trade(
+    trade: schemas.TradeCreate, 
+    db: Session = Depends(get_db),
+    current_user: models.User = Depends(get_current_user),
+    token: str = Depends(get_current_token)
+):
     trade_symbol = trade.symbol.upper()
-    logger.info(f"Processing trade for symbol: {trade_symbol}")
+    logger.info(f"Processing trade for user {current_user.id}, symbol: {trade_symbol}")
 
-    db_asset = db.query(models.Asset).filter(models.Asset.symbol == trade_symbol).first()
+    # Search for the asset globally, not by user_id
+    db_asset = db.query(models.Asset).filter(
+        models.Asset.symbol == trade_symbol
+    ).first()
 
     if not db_asset:
-        logger.info(f"Asset with symbol {trade_symbol} not found. Creating new asset...")
+        logger.info(f"Asset with symbol {trade_symbol} not found globally. Creating new asset...")
         db_asset = models.Asset(
             symbol=trade_symbol,
             name=trade.name,
             asset_type=trade.asset_type,
             industry=trade.industry,
-            id_crypto=trade.id_crypto if hasattr(trade, 'id_crypto') else None
+            id_crypto=trade.id_crypto if hasattr(trade, 'id_crypto') else None,
+            # user_id is no longer part of Asset model
         )
         db.add(db_asset)
         db.commit()
         db.refresh(db_asset)
-        logger.info(f"Created new asset with ID: {db_asset.id}")
+        logger.info(f"Created new global asset with ID: {db_asset.id}")
     else:
-        logger.info(f"Found existing asset with ID: {db_asset.id}")
+        logger.info(f"Found existing global asset with ID: {db_asset.id}")
 
     if trade.trade_type == 'buy':
         investment_account_name = trade.investment_account
         trade_cost = trade.shares * trade.price
         current_balance = 0
+        headers = {"Authorization": f"Bearer {token}"}
         try:
             async with httpx.AsyncClient() as client:
-                response = await client.get(f"{BALANCE_SERVICE_URL}/api/balance/{investment_account_name}")
+                response = await client.get(f"{BALANCE_SERVICE_URL}/api/balance/{investment_account_name}", headers=headers)
                 response.raise_for_status()
                 data = response.json()
                 current_balance = data['balance']
                 logger.info(f"Calculated cash balance for '{investment_account_name}' is {current_balance}")
         except Exception as e:
-            logger.error(f"Could not retrieve balance for validation: {e}")
+            logger.error(f"Could not retrieve balance for validation for user {current_user.id}: {e}")
 
         if float(current_balance) < float(trade_cost):
-            logger.warning(f"Insufficient funds in '{investment_account_name}'. Balance: {current_balance}, Required: {trade_cost}")
+            logger.warning(f"Insufficient funds in '{investment_account_name}' for user {current_user.id}. Balance: {current_balance}, Required: {trade_cost}")
             raise HTTPException(
                 status_code=400,
                 detail=f"Insufficient cash balance in '{investment_account_name}' to complete trade."
             )
 
     trade_data = trade.dict(exclude={'symbol', 'name', 'asset_type', 'industry', 'id_crypto'})
-    db_trade = models.Trade(**trade_data, asset_id=db_asset.id)
+    db_trade = models.Trade(**trade_data, asset_id=db_asset.id, user_id=current_user.id)
     
     if db_trade.trade_type == 'buy':
-        logger.info(f"STOCK PURCHASE: Bought {db_trade.shares} shares of {trade_symbol} at ${db_trade.price:.2f} each.")
+        logger.info(f"STOCK PURCHASE for user {current_user.id}: Bought {db_trade.shares} shares of {trade_symbol} at ${db_trade.price:.2f} each.")
     elif db_trade.trade_type == 'sell':
-        logger.info(f"STOCK SALE: Sold {db_trade.shares} shares of {trade_symbol} at ${db_trade.price:.2f} each.")
+        logger.info(f"STOCK SALE for user {current_user.id}: Sold {db_trade.shares} shares of {trade_symbol} at ${db_trade.price:.2f} each.")
 
     db.add(db_trade)
     db.commit()
@@ -92,13 +104,14 @@ def read_trades(
     investment_account: str = None, 
     skip: int = 0, 
     limit: int = 100, 
-    db: Session = Depends(get_db)
+    db: Session = Depends(get_db),
+    current_user: models.User = Depends(get_current_user)
 ):
-    logger.info(f"Reading trades for account: {investment_account}")
-    query = db.query(models.Trade)
+    logger.info(f"Reading trades for user {current_user.id}, account: {investment_account}")
+    query = db.query(models.Trade).filter(models.Trade.user_id == current_user.id)
     if investment_account:
         query = query.filter(models.Trade.investment_account == investment_account)
     
     trades = query.order_by(models.Trade.date.desc()).offset(skip).limit(limit).all()
-    logger.info(f"Found {len(trades)} trades")
+    logger.info(f"Found {len(trades)} trades for user {current_user.id}")
     return trades