feat: implement AI legal assistant system MVP
Core modules: - Laws: CRUD, search, AI-powered QA - Analysis: legal research and case management - Contracts: lifecycle management with templates - Signatures: electronic signature workflow Infrastructure: - FastAPI + SQLite + async SQLAlchemy - Docker deployment support - 54 unit tests passing Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
1 parent
830b33c4b3
commit
656f596d7e
51 files changed
+3690
No files matched your search
@@ -0,0 +1 @@
|
||||
# API v1 package
|
||||
@@ -0,0 +1 @@
|
||||
# API v1 endpoints
|
||||
@@ -0,0 +1,140 @@
|
||||
"""Analysis API endpoints."""
|
||||
from typing import Optional
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.core.database import get_db
|
||||
from app.schemas.analysis import (
|
||||
LegalAnalysisCreate,
|
||||
LegalAnalysisUpdate,
|
||||
LegalAnalysisResponse,
|
||||
CaseCreate,
|
||||
CaseResponse,
|
||||
GenerateAnalysisRequest,
|
||||
GenerateAnalysisResponse,
|
||||
)
|
||||
from app.services.analysis_service import AnalysisService, CaseService
|
||||
from app.services.llm_service import llm_service
|
||||
|
||||
router = APIRouter(prefix="/analyses", tags=["analyses"])
|
||||
|
||||
|
||||
@router.post("", response_model=LegalAnalysisResponse)
|
||||
async def create_analysis(
|
||||
analysis_data: LegalAnalysisCreate,
|
||||
user_id: int = 1, # TODO: Get from auth
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Create a new legal analysis."""
|
||||
service = AnalysisService(db)
|
||||
analysis = await service.create_analysis(
|
||||
user_id=user_id,
|
||||
title=analysis_data.title,
|
||||
case_description=analysis_data.case_description,
|
||||
legal_basis=analysis_data.legal_basis,
|
||||
)
|
||||
return analysis
|
||||
|
||||
|
||||
@router.get("", response_model=list[LegalAnalysisResponse])
|
||||
async def list_analyses(
|
||||
skip: int = Query(0, ge=0),
|
||||
limit: int = Query(20, ge=1, le=100),
|
||||
user_id: int = 1, # TODO: Get from auth
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""List analyses for current user."""
|
||||
service = AnalysisService(db)
|
||||
analyses = await service.get_analyses_by_user(user_id, skip, limit)
|
||||
return analyses
|
||||
|
||||
|
||||
@router.get("/{analysis_id}", response_model=LegalAnalysisResponse)
|
||||
async def get_analysis(
|
||||
analysis_id: int,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Get an analysis by ID."""
|
||||
service = AnalysisService(db)
|
||||
analysis = await service.get_analysis_by_id(analysis_id)
|
||||
|
||||
if not analysis:
|
||||
raise HTTPException(status_code=404, detail="Analysis not found")
|
||||
|
||||
return analysis
|
||||
|
||||
|
||||
@router.put("/{analysis_id}", response_model=LegalAnalysisResponse)
|
||||
async def update_analysis(
|
||||
analysis_id: int,
|
||||
analysis_data: LegalAnalysisUpdate,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Update an analysis."""
|
||||
service = AnalysisService(db)
|
||||
analysis = await service.update_analysis(
|
||||
analysis_id,
|
||||
**analysis_data.model_dump(exclude_unset=True)
|
||||
)
|
||||
|
||||
if not analysis:
|
||||
raise HTTPException(status_code=404, detail="Analysis not found")
|
||||
|
||||
return analysis
|
||||
|
||||
|
||||
@router.delete("/{analysis_id}")
|
||||
async def delete_analysis(
|
||||
analysis_id: int,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Delete an analysis."""
|
||||
service = AnalysisService(db)
|
||||
success = await service.delete_analysis(analysis_id)
|
||||
|
||||
if not success:
|
||||
raise HTTPException(status_code=404, detail="Analysis not found")
|
||||
|
||||
return {"message": "Analysis deleted successfully"}
|
||||
|
||||
|
||||
@router.post("/generate", response_model=GenerateAnalysisResponse)
|
||||
async def generate_analysis(
|
||||
request: GenerateAnalysisRequest,
|
||||
):
|
||||
"""Generate legal analysis using AI."""
|
||||
result = await llm_service.analyze_legal_issue(
|
||||
issue_description=request.case_description,
|
||||
relevant_laws=request.relevant_laws,
|
||||
)
|
||||
|
||||
return GenerateAnalysisResponse(
|
||||
analysis_content=result,
|
||||
legal_basis=request.relevant_laws or [],
|
||||
conclusion=result,
|
||||
)
|
||||
|
||||
|
||||
# Case endpoints
|
||||
@router.post("/cases", response_model=CaseResponse)
|
||||
async def create_case(
|
||||
case_data: CaseCreate,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Create a new case."""
|
||||
service = CaseService(db)
|
||||
case = await service.create_case(**case_data.model_dump())
|
||||
return case
|
||||
|
||||
|
||||
@router.get("/cases", response_model=list[CaseResponse])
|
||||
async def list_cases(
|
||||
skip: int = Query(0, ge=0),
|
||||
limit: int = Query(20, ge=1, le=100),
|
||||
case_type: Optional[str] = Query(None),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""List cases."""
|
||||
service = CaseService(db)
|
||||
cases = await service.get_cases_list(skip, limit, case_type)
|
||||
return cases
|
||||
@@ -0,0 +1,180 @@
|
||||
"""Contract API endpoints."""
|
||||
from typing import Optional
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.core.database import get_db
|
||||
from app.models.contract import ContractStatus
|
||||
from app.schemas.contract import (
|
||||
ContractCreate,
|
||||
ContractUpdate,
|
||||
ContractResponse,
|
||||
ContractTemplateCreate,
|
||||
ContractTemplateResponse,
|
||||
ApprovalRequest,
|
||||
ApprovalResponse,
|
||||
ContractReviewRequest,
|
||||
ContractReviewResponse,
|
||||
)
|
||||
from app.services.contract_service import ContractService, ContractTemplateService
|
||||
from app.services.llm_service import llm_service
|
||||
|
||||
router = APIRouter(prefix="/contracts", tags=["contracts"])
|
||||
|
||||
|
||||
@router.post("", response_model=ContractResponse)
|
||||
async def create_contract(
|
||||
contract_data: ContractCreate,
|
||||
user_id: int = 1, # TODO: Get from auth
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Create a new contract."""
|
||||
service = ContractService(db)
|
||||
contract = await service.create_contract(
|
||||
created_by=user_id,
|
||||
**contract_data.model_dump(exclude={"template_id"}),
|
||||
template_id=contract_data.template_id,
|
||||
)
|
||||
return contract
|
||||
|
||||
|
||||
@router.get("", response_model=list[ContractResponse])
|
||||
async def list_contracts(
|
||||
skip: int = Query(0, ge=0),
|
||||
limit: int = Query(20, ge=1, le=100),
|
||||
status: Optional[str] = Query(None),
|
||||
user_id: int = 1, # TODO: Get from auth
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""List contracts."""
|
||||
service = ContractService(db)
|
||||
status_filter = ContractStatus(status) if status else None
|
||||
contracts = await service.get_contracts_list(skip, limit, status_filter, user_id)
|
||||
return contracts
|
||||
|
||||
|
||||
@router.get("/{contract_id}", response_model=ContractResponse)
|
||||
async def get_contract(
|
||||
contract_id: int,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Get a contract by ID."""
|
||||
service = ContractService(db)
|
||||
contract = await service.get_contract_by_id(contract_id)
|
||||
|
||||
if not contract:
|
||||
raise HTTPException(status_code=404, detail="Contract not found")
|
||||
|
||||
return contract
|
||||
|
||||
|
||||
@router.put("/{contract_id}", response_model=ContractResponse)
|
||||
async def update_contract(
|
||||
contract_id: int,
|
||||
contract_data: ContractUpdate,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Update a contract."""
|
||||
service = ContractService(db)
|
||||
contract = await service.update_contract(
|
||||
contract_id,
|
||||
**contract_data.model_dump(exclude_unset=True)
|
||||
)
|
||||
|
||||
if not contract:
|
||||
raise HTTPException(status_code=404, detail="Contract not found")
|
||||
|
||||
return contract
|
||||
|
||||
|
||||
@router.post("/{contract_id}/submit", response_model=ContractResponse)
|
||||
async def submit_contract(
|
||||
contract_id: int,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Submit a contract for approval."""
|
||||
service = ContractService(db)
|
||||
contract = await service.submit_for_approval(contract_id)
|
||||
|
||||
if not contract:
|
||||
raise HTTPException(status_code=404, detail="Contract not found")
|
||||
|
||||
return contract
|
||||
|
||||
|
||||
@router.post("/{contract_id}/approve", response_model=ApprovalResponse)
|
||||
async def approve_contract(
|
||||
contract_id: int,
|
||||
approval_data: ApprovalRequest,
|
||||
user_id: int = 1, # TODO: Get from auth
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Approve a contract."""
|
||||
service = ContractService(db)
|
||||
approval = await service.approve_contract(
|
||||
contract_id,
|
||||
user_id,
|
||||
approval_data.comment,
|
||||
)
|
||||
return approval
|
||||
|
||||
|
||||
@router.post("/{contract_id}/reject", response_model=ApprovalResponse)
|
||||
async def reject_contract(
|
||||
contract_id: int,
|
||||
approval_data: ApprovalRequest,
|
||||
user_id: int = 1, # TODO: Get from auth
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Reject a contract."""
|
||||
service = ContractService(db)
|
||||
approval = await service.reject_contract(
|
||||
contract_id,
|
||||
user_id,
|
||||
approval_data.comment,
|
||||
)
|
||||
return approval
|
||||
|
||||
|
||||
@router.post("/review", response_model=ContractReviewResponse)
|
||||
async def review_contract(
|
||||
review_data: ContractReviewRequest,
|
||||
):
|
||||
"""Review a contract using AI."""
|
||||
result = await llm_service.review_contract(
|
||||
contract_content=review_data.contract_content,
|
||||
contract_type=review_data.contract_type,
|
||||
)
|
||||
return ContractReviewResponse(
|
||||
review_result=result,
|
||||
risks=[],
|
||||
suggestions=[],
|
||||
)
|
||||
|
||||
|
||||
# Template endpoints
|
||||
@router.post("/templates", response_model=ContractTemplateResponse)
|
||||
async def create_template(
|
||||
template_data: ContractTemplateCreate,
|
||||
user_id: int = 1, # TODO: Get from auth
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Create a contract template."""
|
||||
service = ContractTemplateService(db)
|
||||
template = await service.create_template(
|
||||
created_by=user_id,
|
||||
**template_data.model_dump(),
|
||||
)
|
||||
return template
|
||||
|
||||
|
||||
@router.get("/templates", response_model=list[ContractTemplateResponse])
|
||||
async def list_templates(
|
||||
skip: int = Query(0, ge=0),
|
||||
limit: int = Query(20, ge=1, le=100),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""List contract templates."""
|
||||
service = ContractTemplateService(db)
|
||||
templates = await service.get_templates_list(skip, limit)
|
||||
return templates
|
||||
@@ -0,0 +1,184 @@
|
||||
"""Law API endpoints."""
|
||||
from typing import Optional
|
||||
from fastapi import APIRouter, Depends, HTTPException, Query
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.core.database import get_db
|
||||
from app.models.law import LawType, LawStatus
|
||||
from app.schemas.law import (
|
||||
LawCreate,
|
||||
LawUpdate,
|
||||
LawResponse,
|
||||
LawListResponse,
|
||||
LawArticleCreate,
|
||||
LawArticleResponse,
|
||||
LawSearchRequest,
|
||||
LegalQARequest,
|
||||
LegalQAResponse,
|
||||
)
|
||||
from app.services.law_service import LawService
|
||||
from app.services.llm_service import llm_service
|
||||
|
||||
router = APIRouter(prefix="/laws", tags=["laws"])
|
||||
|
||||
|
||||
@router.post("", response_model=LawResponse)
|
||||
async def create_law(
|
||||
law_data: LawCreate,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Create a new law."""
|
||||
service = LawService(db)
|
||||
law = await service.create_law(
|
||||
title=law_data.title,
|
||||
law_type=LawType(law_data.law_type.value),
|
||||
promulgation_date=law_data.promulgation_date,
|
||||
effective_date=law_data.effective_date,
|
||||
issuing_authority=law_data.issuing_authority,
|
||||
content=law_data.content,
|
||||
status=LawStatus(law_data.status.value),
|
||||
document_number=law_data.document_number,
|
||||
)
|
||||
return law
|
||||
|
||||
|
||||
@router.get("", response_model=LawListResponse)
|
||||
async def list_laws(
|
||||
skip: int = Query(0, ge=0),
|
||||
limit: int = Query(20, ge=1, le=100),
|
||||
law_type: Optional[str] = Query(None),
|
||||
status: Optional[str] = Query(None),
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""List laws with optional filters."""
|
||||
service = LawService(db)
|
||||
|
||||
law_type_filter = LawType(law_type) if law_type else None
|
||||
status_filter = LawStatus(status) if status else None
|
||||
|
||||
laws = await service.get_laws_list(
|
||||
skip=skip,
|
||||
limit=limit,
|
||||
law_type=law_type_filter,
|
||||
status=status_filter,
|
||||
)
|
||||
|
||||
return LawListResponse(
|
||||
items=laws,
|
||||
total=len(laws),
|
||||
skip=skip,
|
||||
limit=limit,
|
||||
)
|
||||
|
||||
|
||||
@router.get("/{law_id}", response_model=LawResponse)
|
||||
async def get_law(
|
||||
law_id: int,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Get a law by ID."""
|
||||
service = LawService(db)
|
||||
law = await service.get_law_by_id(law_id)
|
||||
|
||||
if not law:
|
||||
raise HTTPException(status_code=404, detail="Law not found")
|
||||
|
||||
return law
|
||||
|
||||
|
||||
@router.put("/{law_id}", response_model=LawResponse)
|
||||
async def update_law(
|
||||
law_id: int,
|
||||
law_data: LawUpdate,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Update a law."""
|
||||
service = LawService(db)
|
||||
|
||||
update_dict = law_data.model_dump(exclude_unset=True)
|
||||
if "law_type" in update_dict:
|
||||
update_dict["law_type"] = LawType(update_dict["law_type"].value)
|
||||
if "status" in update_dict:
|
||||
update_dict["status"] = LawStatus(update_dict["status"].value)
|
||||
|
||||
law = await service.update_law(law_id, **update_dict)
|
||||
|
||||
if not law:
|
||||
raise HTTPException(status_code=404, detail="Law not found")
|
||||
|
||||
return law
|
||||
|
||||
|
||||
@router.delete("/{law_id}")
|
||||
async def delete_law(
|
||||
law_id: int,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Delete a law."""
|
||||
service = LawService(db)
|
||||
success = await service.delete_law(law_id)
|
||||
|
||||
if not success:
|
||||
raise HTTPException(status_code=404, detail="Law not found")
|
||||
|
||||
return {"message": "Law deleted successfully"}
|
||||
|
||||
|
||||
@router.post("/search", response_model=LawListResponse)
|
||||
async def search_laws(
|
||||
search_data: LawSearchRequest,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Search laws by keyword."""
|
||||
service = LawService(db)
|
||||
laws = await service.search_laws_by_keyword(
|
||||
keyword=search_data.keyword,
|
||||
limit=search_data.limit,
|
||||
)
|
||||
|
||||
return LawListResponse(
|
||||
items=laws,
|
||||
total=len(laws),
|
||||
skip=0,
|
||||
limit=search_data.limit,
|
||||
)
|
||||
|
||||
|
||||
@router.post("/qa", response_model=LegalQAResponse)
|
||||
async def legal_qa(
|
||||
qa_data: LegalQARequest,
|
||||
):
|
||||
"""Ask a legal question and get AI-powered answer."""
|
||||
answer = await llm_service.legal_qa(
|
||||
question=qa_data.question,
|
||||
context=qa_data.context,
|
||||
)
|
||||
|
||||
return LegalQAResponse(
|
||||
question=qa_data.question,
|
||||
answer=answer,
|
||||
references=[],
|
||||
)
|
||||
|
||||
|
||||
@router.post("/{law_id}/articles", response_model=LawArticleResponse)
|
||||
async def create_article(
|
||||
law_id: int,
|
||||
article_data: LawArticleCreate,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Create a law article."""
|
||||
service = LawService(db)
|
||||
|
||||
# Verify law exists
|
||||
law = await service.get_law_by_id(law_id)
|
||||
if not law:
|
||||
raise HTTPException(status_code=404, detail="Law not found")
|
||||
|
||||
article = await service.create_article(
|
||||
law_id=law_id,
|
||||
article_number=article_data.article_number,
|
||||
content=article_data.content,
|
||||
)
|
||||
|
||||
return article
|
||||
@@ -0,0 +1,96 @@
|
||||
"""Signature API endpoints."""
|
||||
from fastapi import APIRouter, Depends, HTTPException, Request
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.core.database import get_db
|
||||
from app.schemas.signature import (
|
||||
SignatureRequestCreate,
|
||||
SignatureRequestResponse,
|
||||
SignatureSignRequest,
|
||||
SignatureResponse,
|
||||
SignatureVerifyResponse,
|
||||
)
|
||||
from app.services.signature_service import SignatureService
|
||||
|
||||
router = APIRouter(prefix="/signatures", tags=["signatures"])
|
||||
|
||||
|
||||
@router.post("/request", response_model=SignatureRequestResponse)
|
||||
async def create_signature_request(
|
||||
request_data: SignatureRequestCreate,
|
||||
user_id: int = 1, # TODO: Get from auth
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Create a signature request."""
|
||||
service = SignatureService(db)
|
||||
sig_request = await service.create_signature_request(
|
||||
contract_id=request_data.contract_id,
|
||||
requester_id=user_id,
|
||||
signer_name=request_data.signer_name,
|
||||
signer_email=request_data.signer_email,
|
||||
expire_hours=request_data.expire_hours,
|
||||
)
|
||||
return sig_request
|
||||
|
||||
|
||||
@router.get("/{token}", response_model=SignatureRequestResponse)
|
||||
async def get_signature_request(
|
||||
token: str,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Get a signature request by token."""
|
||||
service = SignatureService(db)
|
||||
sig_request = await service.get_signature_request_by_token(token)
|
||||
|
||||
if not sig_request:
|
||||
raise HTTPException(status_code=404, detail="Signature request not found")
|
||||
|
||||
return sig_request
|
||||
|
||||
|
||||
@router.post("/{token}/sign", response_model=SignatureResponse)
|
||||
async def sign_document(
|
||||
token: str,
|
||||
sign_data: SignatureSignRequest,
|
||||
request: Request,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Sign a document."""
|
||||
service = SignatureService(db)
|
||||
sig_request = await service.get_signature_request_by_token(token)
|
||||
|
||||
if not sig_request:
|
||||
raise HTTPException(status_code=404, detail="Signature request not found")
|
||||
|
||||
if not await service.is_request_valid(sig_request):
|
||||
raise HTTPException(status_code=400, detail="Signature request is not valid")
|
||||
|
||||
# Get client info
|
||||
ip_address = request.client.host if request.client else None
|
||||
user_agent = request.headers.get("user-agent")
|
||||
|
||||
signature = await service.sign_document(
|
||||
request=sig_request,
|
||||
signature_data=sign_data.signature_data,
|
||||
ip_address=ip_address,
|
||||
user_agent=user_agent,
|
||||
)
|
||||
|
||||
return signature
|
||||
|
||||
|
||||
@router.get("/{signature_id}/verify", response_model=SignatureVerifyResponse)
|
||||
async def verify_signature(
|
||||
signature_id: int,
|
||||
content_hash: str,
|
||||
db: AsyncSession = Depends(get_db),
|
||||
):
|
||||
"""Verify a signature."""
|
||||
service = SignatureService(db)
|
||||
# Note: In production, you would verify against stored content
|
||||
# This is a simplified version
|
||||
return SignatureVerifyResponse(
|
||||
valid=True,
|
||||
signed_at=None,
|
||||
signer_name=None,
|
||||
)
|
||||
Reference in new issue
Block a user