POS Workflow

class CashSession(Base):
    """Sesión de Caja (Turno de Cajero).

    Controla el ciclo de vida de una caja registradora.
    """
    __tablename__ = "cash_sessions"

    id = Column(Integer, primary_key=True)
    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    
    start_time = Column(DateTime(timezone=True), server_default=func.now())
    end_time = Column(DateTime(timezone=True), nullable=True)
    
    start_amount = Column(Numeric(15, 2), nullable=False)
    final_cash_system = Column(Numeric(15, 2), default=0)
    final_cash_declared = Column(Numeric(15, 2), default=0)
    difference = Column(Numeric(15, 2), default=0)
    
    status = Column(String(20), default="OPEN", index=True)
    
    user = relationship("app.models.user.User", backref="cash_sessions")

@router.post("/open", response_model=CashSessionOut)
def open_session(
    session_in: CashSessionCreate, 
    db: Session = Depends(get_tenant_db),
    local_user: User = Depends(get_current_local_user)
):
    """Abre una nueva sesión de caja."""
    user_id = local_user.id

    # Check for existing open session
    active_session = db.query(CashSession).filter(
        CashSession.user_id == user_id,
        CashSession.status == "OPEN"
    ).first()
    
    if active_session:
        if session_in.force_close_previous:
            active_session.status = "CLOSED_SYSTEM"
            active_session.end_time = datetime.now()
            db.commit()
        else:
            raise HTTPException(
                status_code=409, 
                detail=f"Ya existe una caja abierta (ID: {active_session.id})"
            )

    new_session = CashSession(
        user_id=user_id,
        start_amount=session_in.start_amount,
        status="OPEN"
    )
    db.add(new_session)
    db.commit()
    return new_session

@router.post("/close", response_model=CashSessionOut)
def close_session(
    close_in: CashSessionClose, 
    db: Session = Depends(get_tenant_db),
    local_user: User = Depends(get_current_local_user)
):
    """Cierra la sesión de caja y realiza arqueo."""
    user_id = local_user.id
    active_session = db.query(CashSession).filter(
        CashSession.user_id == user_id,
        CashSession.status == "OPEN"
    ).first()
    
    if not active_session:
        raise HTTPException(status_code=404, detail="No hay caja abierta")

    # Calculate System Total
    total_sales_cash = db.query(func.coalesce(func.sum(SalePayment.amount), 0))\
        .join(Sale)\
        .join(PaymentMethod)\
        .filter(
            Sale.created_at >= active_session.start_time,
            Sale.seller_id == user_id,
            PaymentMethod.code == "EFECTIVO"
        ).scalar()
    
    final_system = active_session.start_amount + total_sales_cash
    
    active_session.end_time = get_now()
    active_session.final_cash_system = final_system
    active_session.final_cash_declared = close_in.final_cash_declared
    active_session.difference = close_in.final_cash_declared - final_system
    active_session.status = "CLOSED"
    
    db.commit()
    return active_session

class PaymentMethod(Base):
    """Medio de Pago."""
    __tablename__ = "payment_methods"

    id = Column(Integer, primary_key=True)
    code = Column(String(50), unique=True, nullable=False)
    name = Column(String(100), nullable=False)
    is_active = Column(Boolean, default=True)

pay_method = db.query(PaymentMethod).get(payment_in.payment_method_id)
if pay_method and pay_method.code == "CREDITO_INTERNO":
    customer.current_balance += payment_in.amount
    db.add(customer)

@router.post("/return", response_model=SaleOut)
def create_return(
    return_in: ReturnCreate, 
    db: Session = Depends(get_tenant_db)
):
    """Registra una Devolución (Nota de Crédito)."""
    
    # 1. Find original sale
    original_sale = db.query(Sale).get(return_in.original_sale_id)
    if not original_sale:
        raise HTTPException(status_code=404, 
                          detail="Venta original no encontrada")

    # 2. Restock inventory
    for item in return_in.items:
        product = db.query(Product).get(item.product_id)
        
        if product.controla_stock:
            product.stock_actual += item.cantidad
            
            movement = StockMovement(
                product_id=product.id,
                user_id=user_id,
                tipo="ENTRADA",
                motivo="DEVOLUCION",
                cantidad=item.cantidad,
                description=f"Devolución venta f.{original_sale.folio}"
            )
            stock_movements.append(movement)
    
    # 3. Generate Credit Note (DTE 61)
    referencias_json = [{
        "tipo_documento": str(original_sale.tipo_dte),
        "folio": str(original_sale.folio),
        "fecha": original_sale.fecha_emision.strftime("%Y-%m-%d"),
        "sii_reason_code": return_in.sii_reason_code
    }]

    nc_sale = Sale(
        customer_id=original_sale.customer_id,
        folio=nuevo_folio,
        tipo_dte=61,  # Credit Note
        referencias=referencias_json,
        related_sale_id=original_sale.id
    )
    
    # 4. Process refund
    method = db.query(PaymentMethod).get(return_in.return_method_id)
    if method.code == "CREDITO_INTERNO":
        customer.current_balance -= total  # Reduce debt
    
    db.commit()
    return nc_sale