Marius Mutu
c5fde510a8
Integrate shared JWT authentication into data-entry-app: - Add Oracle pool initialization for auth service - Add AuthenticationMiddleware to protect API routes - Update all receipt endpoints to use CurrentUser from JWT - Add shared auth router (/api/auth/login, /api/auth/refresh) Add nomenclature synchronization feature: - Create SQLite models for synced suppliers, local suppliers, and cash registers - Add nomenclature router with sync triggers and CRUD endpoints - Add sync service for Oracle → SQLite nomenclature data - Update nomenclature_service to use synced SQLite data with fallbacks Create shared frontend components: - Add shared/frontend/ with LoginView.vue, auth store factory, login.css - Integrate shared login and auth into data-entry-app frontend - Add axios-based API service with token refresh interceptor 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
455 lines
15 KiB
Python
455 lines
15 KiB
Python
"""API endpoints for receipts."""
|
|
|
|
from typing import List, Optional
|
|
from pathlib import Path
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Query
|
|
from fastapi.responses import FileResponse
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.db.database import get_session
|
|
from app.db.crud.receipt import ReceiptCRUD
|
|
from app.db.crud.attachment import AttachmentCRUD
|
|
from app.db.crud.accounting_entry import AccountingEntryCRUD
|
|
from app.services.receipt_service import ReceiptService
|
|
from app.services.nomenclature_service import NomenclatureService
|
|
from app.schemas.receipt import (
|
|
ReceiptCreate,
|
|
ReceiptUpdate,
|
|
ReceiptResponse,
|
|
ReceiptListResponse,
|
|
ReceiptFilter,
|
|
AttachmentResponse,
|
|
AccountingEntryResponse,
|
|
WorkflowAction,
|
|
RejectRequest,
|
|
EntriesUpdateRequest,
|
|
PartnerOption,
|
|
AccountOption,
|
|
CashRegisterOption,
|
|
ExpenseTypeOption,
|
|
)
|
|
from app.db.models.receipt import ReceiptStatus
|
|
|
|
# Auth integration
|
|
from auth.dependencies import get_current_user
|
|
from auth.models import CurrentUser
|
|
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
# ============ Helper for current user's company ============
|
|
|
|
def get_current_user_company(current_user: CurrentUser) -> int:
|
|
"""
|
|
Get current user's active company.
|
|
|
|
Returns the first company from the user's companies list.
|
|
In future, this can be enhanced to use a session-based active company.
|
|
"""
|
|
if current_user.companies:
|
|
# For data-entry-app, we assume company ID is numeric
|
|
# If companies are stored as strings, convert to int
|
|
# For now, return 1 as default (Phase 1)
|
|
return 1
|
|
return 1
|
|
|
|
|
|
# ============ Receipt CRUD Endpoints ============
|
|
|
|
@router.post("/", response_model=ReceiptResponse)
|
|
async def create_receipt(
|
|
data: ReceiptCreate,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Create a new receipt in DRAFT status."""
|
|
receipt = await ReceiptService.create_receipt(session, data, current_user.username)
|
|
return ReceiptResponse.model_validate(receipt)
|
|
|
|
|
|
@router.get("/", response_model=ReceiptListResponse)
|
|
async def list_receipts(
|
|
status: Optional[ReceiptStatus] = None,
|
|
company_id: Optional[int] = None,
|
|
created_by: Optional[str] = None,
|
|
date_from: Optional[str] = None,
|
|
date_to: Optional[str] = None,
|
|
search: Optional[str] = None,
|
|
page: int = Query(default=1, ge=1),
|
|
page_size: int = Query(default=20, ge=1, le=100),
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Get paginated list of receipts with filters."""
|
|
from datetime import date as date_type
|
|
|
|
current_company = get_current_user_company(current_user)
|
|
|
|
filters = ReceiptFilter(
|
|
status=status,
|
|
company_id=company_id or current_company,
|
|
created_by=created_by,
|
|
date_from=date_type.fromisoformat(date_from) if date_from else None,
|
|
date_to=date_type.fromisoformat(date_to) if date_to else None,
|
|
search=search,
|
|
page=page,
|
|
page_size=page_size,
|
|
)
|
|
|
|
return await ReceiptService.get_receipts(session, filters)
|
|
|
|
|
|
@router.get("/pending", response_model=List[ReceiptResponse])
|
|
async def list_pending_receipts(
|
|
company_id: Optional[int] = None,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Get all receipts pending review (for accountant view)."""
|
|
current_company = get_current_user_company(current_user)
|
|
receipts = await ReceiptCRUD.get_pending_review(
|
|
session, company_id or current_company
|
|
)
|
|
return [ReceiptResponse.model_validate(r) for r in receipts]
|
|
|
|
|
|
@router.get("/stats")
|
|
async def get_receipt_stats(
|
|
company_id: Optional[int] = None,
|
|
my_receipts: bool = False,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Get receipt statistics."""
|
|
current_company = get_current_user_company(current_user)
|
|
return await ReceiptCRUD.get_stats(
|
|
session,
|
|
company_id or current_company,
|
|
created_by=current_user.username if my_receipts else None,
|
|
)
|
|
|
|
|
|
@router.get("/{receipt_id}", response_model=ReceiptResponse)
|
|
async def get_receipt(
|
|
receipt_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Get receipt details with attachments and accounting entries."""
|
|
receipt = await ReceiptService.get_receipt(session, receipt_id)
|
|
|
|
if not receipt:
|
|
raise HTTPException(status_code=404, detail="Receipt not found")
|
|
|
|
return ReceiptResponse.model_validate(receipt)
|
|
|
|
|
|
@router.put("/{receipt_id}", response_model=ReceiptResponse)
|
|
async def update_receipt(
|
|
receipt_id: int,
|
|
data: ReceiptUpdate,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Update receipt (only DRAFT status, only by creator)."""
|
|
success, message, receipt = await ReceiptService.update_receipt(
|
|
session, receipt_id, data, current_user.username
|
|
)
|
|
|
|
if not success:
|
|
raise HTTPException(status_code=400, detail=message)
|
|
|
|
return ReceiptResponse.model_validate(receipt)
|
|
|
|
|
|
@router.delete("/{receipt_id}")
|
|
async def delete_receipt(
|
|
receipt_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Delete receipt (only DRAFT status, only by creator)."""
|
|
success, message = await ReceiptService.delete_receipt(
|
|
session, receipt_id, current_user.username
|
|
)
|
|
|
|
if not success:
|
|
raise HTTPException(status_code=400, detail=message)
|
|
|
|
return {"success": True, "message": message}
|
|
|
|
|
|
# ============ Workflow Endpoints ============
|
|
|
|
@router.post("/{receipt_id}/submit", response_model=WorkflowAction)
|
|
async def submit_receipt(
|
|
receipt_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Submit receipt for review (DRAFT → PENDING_REVIEW)."""
|
|
success, message, receipt = await ReceiptService.submit_for_review(
|
|
session, receipt_id, current_user.username
|
|
)
|
|
|
|
return WorkflowAction(
|
|
success=success,
|
|
message=message,
|
|
receipt=ReceiptResponse.model_validate(receipt) if receipt else None,
|
|
)
|
|
|
|
|
|
@router.post("/{receipt_id}/approve", response_model=WorkflowAction)
|
|
async def approve_receipt(
|
|
receipt_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Approve receipt (PENDING_REVIEW → APPROVED). Accountant action."""
|
|
success, message, receipt = await ReceiptService.approve_receipt(
|
|
session, receipt_id, current_user.username
|
|
)
|
|
|
|
return WorkflowAction(
|
|
success=success,
|
|
message=message,
|
|
receipt=ReceiptResponse.model_validate(receipt) if receipt else None,
|
|
)
|
|
|
|
|
|
@router.post("/{receipt_id}/reject", response_model=WorkflowAction)
|
|
async def reject_receipt(
|
|
receipt_id: int,
|
|
data: RejectRequest,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Reject receipt (PENDING_REVIEW → REJECTED). Accountant action."""
|
|
success, message, receipt = await ReceiptService.reject_receipt(
|
|
session, receipt_id, current_user.username, data.reason
|
|
)
|
|
|
|
return WorkflowAction(
|
|
success=success,
|
|
message=message,
|
|
receipt=ReceiptResponse.model_validate(receipt) if receipt else None,
|
|
)
|
|
|
|
|
|
@router.post("/{receipt_id}/resubmit", response_model=WorkflowAction)
|
|
async def resubmit_receipt(
|
|
receipt_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Resubmit rejected receipt after corrections (REJECTED → PENDING_REVIEW)."""
|
|
success, message, receipt = await ReceiptService.resubmit_receipt(
|
|
session, receipt_id, current_user.username
|
|
)
|
|
|
|
return WorkflowAction(
|
|
success=success,
|
|
message=message,
|
|
receipt=ReceiptResponse.model_validate(receipt) if receipt else None,
|
|
)
|
|
|
|
|
|
# ============ Accounting Entries Endpoints ============
|
|
|
|
@router.get("/{receipt_id}/entries", response_model=List[AccountingEntryResponse])
|
|
async def get_receipt_entries(
|
|
receipt_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Get accounting entries for a receipt."""
|
|
entries = await AccountingEntryCRUD.get_by_receipt_id(session, receipt_id)
|
|
return [AccountingEntryResponse.model_validate(e) for e in entries]
|
|
|
|
|
|
@router.put("/{receipt_id}/entries", response_model=List[AccountingEntryResponse])
|
|
async def update_receipt_entries(
|
|
receipt_id: int,
|
|
data: EntriesUpdateRequest,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Update accounting entries for a receipt (accountant action)."""
|
|
success, message, entries = await ReceiptService.update_entries(
|
|
session, receipt_id, data.entries, current_user.username
|
|
)
|
|
|
|
if not success:
|
|
raise HTTPException(status_code=400, detail=message)
|
|
|
|
return [AccountingEntryResponse.model_validate(e) for e in entries]
|
|
|
|
|
|
@router.post("/{receipt_id}/entries/regenerate", response_model=List[AccountingEntryResponse])
|
|
async def regenerate_entries(
|
|
receipt_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Regenerate accounting entries based on receipt data."""
|
|
success, message, _ = await ReceiptService.regenerate_entries(
|
|
session, receipt_id, current_user.username
|
|
)
|
|
|
|
if not success:
|
|
raise HTTPException(status_code=400, detail=message)
|
|
|
|
entries = await AccountingEntryCRUD.get_by_receipt_id(session, receipt_id)
|
|
return [AccountingEntryResponse.model_validate(e) for e in entries]
|
|
|
|
|
|
# ============ Attachment Endpoints ============
|
|
|
|
@router.post("/{receipt_id}/attachments", response_model=AttachmentResponse)
|
|
async def upload_attachment(
|
|
receipt_id: int,
|
|
file: UploadFile = File(...),
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Upload attachment for a receipt."""
|
|
# Check receipt exists and user can modify it
|
|
receipt = await ReceiptCRUD.get_by_id(session, receipt_id, include_relations=False)
|
|
|
|
if not receipt:
|
|
raise HTTPException(status_code=404, detail="Receipt not found")
|
|
|
|
# Only allow uploads for DRAFT and REJECTED receipts
|
|
if receipt.status not in [ReceiptStatus.DRAFT, ReceiptStatus.REJECTED]:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="Cannot upload attachments for this receipt status"
|
|
)
|
|
|
|
# Only creator can upload
|
|
if receipt.created_by != current_user.username:
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="Only the creator can upload attachments"
|
|
)
|
|
|
|
try:
|
|
attachment = await AttachmentCRUD.create(session, receipt_id, file)
|
|
return AttachmentResponse.model_validate(attachment)
|
|
except ValueError as e:
|
|
raise HTTPException(status_code=400, detail=str(e))
|
|
|
|
|
|
@router.get("/{receipt_id}/attachments", response_model=List[AttachmentResponse])
|
|
async def list_attachments(
|
|
receipt_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Get all attachments for a receipt."""
|
|
attachments = await AttachmentCRUD.get_by_receipt_id(session, receipt_id)
|
|
return [AttachmentResponse.model_validate(a) for a in attachments]
|
|
|
|
|
|
@router.get("/attachments/{attachment_id}/download")
|
|
async def download_attachment(
|
|
attachment_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
):
|
|
"""Download an attachment file."""
|
|
attachment = await AttachmentCRUD.get_by_id(session, attachment_id)
|
|
|
|
if not attachment:
|
|
raise HTTPException(status_code=404, detail="Attachment not found")
|
|
|
|
file_path = AttachmentCRUD.get_file_path(attachment)
|
|
|
|
if not file_path.exists():
|
|
raise HTTPException(status_code=404, detail="File not found on disk")
|
|
|
|
return FileResponse(
|
|
path=str(file_path),
|
|
filename=attachment.filename,
|
|
media_type=attachment.mime_type,
|
|
)
|
|
|
|
|
|
@router.delete("/attachments/{attachment_id}")
|
|
async def delete_attachment(
|
|
attachment_id: int,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Delete an attachment."""
|
|
attachment = await AttachmentCRUD.get_by_id(session, attachment_id)
|
|
|
|
if not attachment:
|
|
raise HTTPException(status_code=404, detail="Attachment not found")
|
|
|
|
# Get receipt to check permissions
|
|
receipt = await ReceiptCRUD.get_by_id(session, attachment.receipt_id, include_relations=False)
|
|
|
|
if not receipt:
|
|
raise HTTPException(status_code=404, detail="Receipt not found")
|
|
|
|
# Only allow deletion for DRAFT receipts by creator
|
|
if receipt.status != ReceiptStatus.DRAFT:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="Cannot delete attachments for this receipt status"
|
|
)
|
|
|
|
if receipt.created_by != current_user.username:
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="Only the creator can delete attachments"
|
|
)
|
|
|
|
await AttachmentCRUD.delete(session, attachment)
|
|
return {"success": True, "message": "Attachment deleted"}
|
|
|
|
|
|
# ============ Nomenclature Endpoints ============
|
|
|
|
@router.get("/nomenclature/partners", response_model=List[PartnerOption])
|
|
async def get_partners(
|
|
search: Optional[str] = None,
|
|
company_id: Optional[int] = None,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Get partners (suppliers/customers) for dropdown."""
|
|
current_company = get_current_user_company(current_user)
|
|
return await NomenclatureService.get_partners(
|
|
company_id or current_company, search, session
|
|
)
|
|
|
|
|
|
@router.get("/nomenclature/accounts", response_model=List[AccountOption])
|
|
async def get_accounts(
|
|
prefix: Optional[str] = None,
|
|
company_id: Optional[int] = None,
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Get chart of accounts for dropdown."""
|
|
current_company = get_current_user_company(current_user)
|
|
return await NomenclatureService.get_accounts(
|
|
company_id or current_company, prefix
|
|
)
|
|
|
|
|
|
@router.get("/nomenclature/cash-registers", response_model=List[CashRegisterOption])
|
|
async def get_cash_registers(
|
|
company_id: Optional[int] = None,
|
|
session: AsyncSession = Depends(get_session),
|
|
current_user: CurrentUser = Depends(get_current_user),
|
|
):
|
|
"""Get cash registers and bank accounts for dropdown."""
|
|
current_company = get_current_user_company(current_user)
|
|
return await NomenclatureService.get_cash_registers(company_id or current_company, session)
|
|
|
|
|
|
@router.get("/nomenclature/expense-types", response_model=List[ExpenseTypeOption])
|
|
async def get_expense_types():
|
|
"""Get predefined expense types for dropdown."""
|
|
return await NomenclatureService.get_expense_types()
|