Najwiekszy bugfix w miescie (#56)

* Najwiekszy bugfix w miescie

* Visual fixes

* Fixed marketplace confirmation

* compile fix

* Fix

* Error display fix

* tests

Author: Jlisowskyy

.concat.conf

@@ -1,5 +1,5 @@
-frontend/lib
-bbackend/tests
+Afrontend/lib
+backend/tests
 backend/user_auth_service/app
-bbackend/event_ticketing_service/app
+backend/event_ticketing_service/app
 

\

@@ -0,0 +1,5 @@
+frontend/lib
+Abackend/tests
+Abackend/user_auth_service/app
+backend/event_ticketing_service/app
+

backend/event_ticketing_service/app/repositories/cart_repository.py

@@ -160,11 +160,12 @@ def add_item_from_resell(self, customer_id: int, ticket_id: int) -> CartItemMode
 
     def remove_item(self, customer_id: int, cart_item_id: int) -> bool:
         # Get the shopping cart for the customer
-        cart = self.db.query(ShoppingCartModel).filter(ShoppingCartModel.customer_id == customer_id).first()
+        cart = self.db.query(ShoppingCartModel).filter(
+            ShoppingCartModel.customer_id == customer_id).first()
         if not cart:
-            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Shopping cart not found")
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND,
+                                detail="Shopping cart not found")
 
-        # Find the cart item to remove
         cart_item_to_remove = (
             self.db.query(CartItemModel)
             .filter(CartItemModel.cart_item_id == cart_item_id, CartItemModel.cart_id == cart.cart_id)
@@ -179,7 +180,6 @@ def remove_item(self, customer_id: int, cart_item_id: int) -> bool:
 
         self.db.delete(cart_item_to_remove)
         self.db.commit()
-        logger.info(f"Removed cart_item_id {cart_item_id} from cart_id {cart.cart_id} of customer_id {customer_id}")
         return True
 
     #----------------------------------------------------------

backend/event_ticketing_service/app/routers/cart.py

@@ -32,16 +32,16 @@ async def get_shopping_cart(
     cart_repo: CartRepository = Depends(get_cart_repository)
 ):
     """Get items in the user's shopping cart"""
-    logger.info(f"Get shopping cart of {user}")
+    logger.info(f"Get shopping cart for user_id {user['user_id']}")
     user_id = user["user_id"]
-    logger.info(f"Get shopping cart for user_id {user_id}")
 
     cart_items_models = cart_repo.get_cart_items_details(customer_id=user_id)
 
     response_items: List[CartItemWithDetails] = []
     for item_model in cart_items_models:
         if item_model.ticket_type:
             cart_item_detail = CartItemWithDetails(
+                cart_item_id=item_model.cart_item_id,
                 ticket_type=TicketType.model_validate(item_model.ticket_type),
                 quantity=item_model.quantity
             )
@@ -72,10 +72,15 @@ async def add_to_cart(
         )
 
         return CartItemWithDetails(
+            cart_item_id=cart_item_model.cart_item_id,
             ticket_type=TicketType.model_validate(cart_item_model.ticket_type),
             quantity=cart_item_model.quantity
         )
 
+    raise HTTPException(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        detail="Ticket type ID is required."
+    )
 
 @router.delete(
     "/items/{cart_item_id}",

backend/event_ticketing_service/app/routers/events.py

@@ -1,32 +1,36 @@
-from typing import List
-from datetime import datetime, timedelta
+from typing import List, Optional
+from datetime import datetime
 
 from app.database import get_db
 from sqlalchemy.orm import Session
-from fastapi import Path, Depends, APIRouter
+from sqlalchemy import or_, and_, desc, asc
+from fastapi import Path, Depends, APIRouter, Query, HTTPException, status
 from app.filters.events_filter import EventsFilter
 from app.repositories.event_repository import EventRepository, get_event_repository
 from app.schemas.event import EventBase, EventUpdate, EventDetails, NotificationRequest
 from app.utils.jwt_auth import get_current_organizer, get_current_admin
+from app.models.events import EventModel
+from app.models.location import LocationModel
+from app.models.ticket_type import TicketTypeModel
 
 router = APIRouter(prefix="/events", tags=["events"])
 
 
 @router.post("/", response_model=EventDetails)
 async def create_event(
-    event_data: EventBase,
-    event_repo: EventRepository = Depends(get_event_repository),
-    current_organizer = Depends(get_current_organizer)
+        event_data: EventBase,
+        event_repo: EventRepository = Depends(get_event_repository),
+        current_organizer=Depends(get_current_organizer)
 ):
     """Create a new event (requires authentication)"""
     return event_repo.create_event(event_data, current_organizer["role_id"])
 
 
 @router.post("/authorize/{event_id}", response_model=bool)
 async def authorize_event(
-    event_id: int = Path(..., title="Event ID"),
-    event_repo: EventRepository = Depends(get_event_repository),
-    current_admin = Depends(get_current_admin)
+        event_id: int = Path(..., title="Event ID"),
+        event_repo: EventRepository = Depends(get_event_repository),
+        current_admin=Depends(get_current_admin)
 ):
     """Authorize an event (requires admin authentication)"""
     event_repo.authorize_event(event_id)
@@ -35,9 +39,9 @@ async def authorize_event(
 
 @router.post("/reject/{event_id}", response_model=bool)
 async def reject_event(
-    event_id: int = Path(..., title="Event ID"),
-    event_repo: EventRepository = Depends(get_event_repository),
-    current_admin = Depends(get_current_admin)
+        event_id: int = Path(..., title="Event ID"),
+        event_repo: EventRepository = Depends(get_event_repository),
+        current_admin=Depends(get_current_admin)
 ):
     """Reject an event (requires admin authentication)"""
     event_repo.reject_event(event_id)
@@ -46,38 +50,151 @@ async def reject_event(
 
 @router.get("", response_model=List[EventDetails])
 def get_events_endpoint(
-    filters: EventsFilter = Depends(),
-    event_repo: EventRepository = Depends(get_event_repository),
+        page: int = Query(1, ge=1, description="Page number"),
+        limit: int = Query(50, ge=1, le=100, description="Items per page"),
+        search: Optional[str] = Query(None, description="Search by event name or description"),
+        location: Optional[str] = Query(None, description="Filter by location name"),
+        start_date_from: Optional[datetime] = Query(None,
+                                                    description="Events starting after this date"),
+        start_date_to: Optional[datetime] = Query(None,
+                                                  description="Events starting before this date"),
+        min_price: Optional[float] = Query(None, ge=0,
+                                           description="Minimum ticket price available"),
+        max_price: Optional[float] = Query(None, ge=0,
+                                           description="Maximum ticket price available"),
+        organizer_id: Optional[int] = Query(None, description="Filter by specific organizer"),
+        minimum_age: Optional[int] = Query(None, ge=0,
+                                           description="Minimum required age for attendees"),
+        status: Optional[str] = Query(None, description="Filter by event status"),
+        categories: Optional[str] = Query(None,
+                                          description="Filter by categories (comma-separated)"),
+        sort_by: str = Query("start_date",
+                             description="Sort field (start_date, name, creation_date)"),
+        sort_order: str = Query("asc", description="Sort order (asc/desc)"),
+        db: Session = Depends(get_db),
 ):
-    events = event_repo.get_events(filters)
+    """
+    Get list of events with advanced filtering, searching, and pagination
+    """
+    # Build the query with joins for filtering
+    query = db.query(EventModel).join(LocationModel,
+                                      EventModel.location_id == LocationModel.location_id)
+
+    # Apply search filter
+    if search:
+        search_filter = f"%{search}%"
+        query = query.filter(
+            or_(
+                EventModel.name.ilike(search_filter),
+                EventModel.description.ilike(search_filter)
+            )
+        )
+
+    # Apply location filter
+    if location:
+        query = query.filter(LocationModel.name.ilike(f"%{location}%"))
+
+    # Apply date filters
+    if start_date_from:
+        query = query.filter(EventModel.start_date >= start_date_from)
+    if start_date_to:
+        query = query.filter(EventModel.start_date <= start_date_to)
+
+    # Apply organizer filter
+    if organizer_id:
+        query = query.filter(EventModel.organizer_id == organizer_id)
+
+    # Apply minimum age filter
+    if minimum_age:
+        query = query.filter(EventModel.minimum_age >= minimum_age)
+
+    # Apply status filter
+    if status:
+        if status not in ["pending", "created", "rejected", "cancelled"]:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Invalid status. Must be one of: pending, created, rejected, cancelled"
+            )
+        query = query.filter(EventModel.status == status)
+
+    # Apply price filters (requires subquery on ticket types)
+    if min_price is not None or max_price is not None:
+        price_subquery = db.query(TicketTypeModel.event_id).distinct()
+        if min_price is not None:
+            price_subquery = price_subquery.filter(TicketTypeModel.price >= min_price)
+        if max_price is not None:
+            price_subquery = price_subquery.filter(TicketTypeModel.price <= max_price)
+
+        query = query.filter(EventModel.event_id.in_(price_subquery))
+
+    # Apply categories filter (simplified - assuming categories are stored as comma-separated values in description or using JSON)
+    if categories:
+        category_list = [cat.strip() for cat in categories.split(",")]
+        category_filters = [EventModel.description.ilike(f"%{cat}%") for cat in category_list]
+        query = query.filter(or_(*category_filters))
+
+    # Apply sorting
+    if sort_by not in ["start_date", "name", "creation_date"]:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid sort_by. Must be one of: start_date, name, creation_date"
+        )
+
+    if sort_order not in ["asc", "desc"]:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid sort_order. Must be 'asc' or 'desc'"
+        )
+
+    # Map sort fields
+    sort_field_map = {
+        "start_date": EventModel.start_date,
+        "name": EventModel.name,
+        "creation_date": EventModel.event_id  # Assuming event_id correlates with creation order
+    }
+
+    sort_field = sort_field_map[sort_by]
+    if sort_order == "desc":
+        query = query.order_by(desc(sort_field))
+    else:
+        query = query.order_by(asc(sort_field))
+
+    # Apply pagination
+    offset = (page - 1) * limit
+    query = query.offset(offset).limit(limit)
+
+    # Execute query and get results
+    events = query.all()
+
+    # Convert to response models
     return [EventDetails.model_validate(e) for e in events]
 
 
 @router.put("/{event_id}", response_model=EventDetails)
 def update_event_endpoint(
-    event_id: int = Path(..., title="Event ID"),
-    update_data: EventUpdate = Depends(),
-    event_repo: EventRepository = Depends(get_event_repository),
-    current_organizer = Depends(get_current_organizer)
+        event_id: int = Path(..., title="Event ID"),
+        update_data: EventUpdate = Depends(),
+        event_repo: EventRepository = Depends(get_event_repository),
+        current_organizer=Depends(get_current_organizer)
 ):
     return event_repo.update_event(event_id, update_data, current_organizer["role_id"])
 
 
 @router.delete("/{event_id}", response_model=bool)
 def cancel_event_endpoint(
-    event_id: int = Path(..., title="Event ID"),
-    event_repo: EventRepository = Depends(get_event_repository),
-    current_organizer = Depends(get_current_organizer)
+        event_id: int = Path(..., title="Event ID"),
+        event_repo: EventRepository = Depends(get_event_repository),
+        current_organizer=Depends(get_current_organizer)
 ):
     event_repo.cancel_event(event_id, current_organizer["role_id"])
     return True
 
 
 @router.post("/{event_id}/notify")
 async def notify_participants(
-    event_id: int = Path(..., title="Event ID"),
-    notification: NotificationRequest = None,
-    current_organizer = Depends(get_current_organizer),
+        event_id: int = Path(..., title="Event ID"),
+        notification: NotificationRequest = None,
+        current_organizer=Depends(get_current_organizer),
 ):
     """Notify participants of an event (requires organizer authentication)"""
     return {