Skip to content

A modern platform for visual, flexible, and extensible graph-based investigations. For cybersecurity analysts and investigators.

2.9 KB
Raw Blame
from typing import List
from uuid import UUID

from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session

from app.api.deps import get_current_user
from app.api.schemas.key import KeyCreate, KeyExists, KeyRead
from flowsint_core.core.models import Profile
from flowsint_core.core.postgre_db import get_db
from flowsint_core.core.services import (
    DatabaseError,
    NotFoundError,
    create_key_service,
)

router = APIRouter()


@router.get("", response_model=List[KeyRead])
def get_keys(
    db: Session = Depends(get_db), current_user: Profile = Depends(get_current_user)
):
    service = create_key_service(db)
    keys = service.get_keys_for_user(current_user.id)
    return [
        KeyRead(
            id=key.id,
            owner_id=key.owner_id,
            name=key.name,
            created_at=key.created_at,
        )
        for key in keys
    ]


@router.get("/chat-key-exists", response_model=KeyExists)
def chat_key_exists(
    db: Session = Depends(get_db),
    current_user: Profile = Depends(get_current_user),
):
    """
    A simple util route to know if any ai chat key exists in the vault for this user
    """
    service = create_key_service(db)
    try:
        key_exists = service.chat_key_exist(current_user.id)
        return KeyExists(exists=key_exists)
    except NotFoundError as e:
        print(e)
        return KeyExists(exists=False)


@router.get("/{id}", response_model=KeyRead)
def get_key_by_id(
    id: UUID,
    db: Session = Depends(get_db),
    current_user: Profile = Depends(get_current_user),
):
    service = create_key_service(db)
    try:
        key = service.get_key_by_id(id, current_user.id)
        return KeyRead(
            id=key.id,
            owner_id=key.owner_id,
            name=key.name,
            created_at=key.created_at,
        )
    except NotFoundError:
        raise HTTPException(status_code=404, detail="Key not found")


@router.post("/create", response_model=KeyRead, status_code=status.HTTP_201_CREATED)
def create_key(
    payload: KeyCreate,
    db: Session = Depends(get_db),
    current_user: Profile = Depends(get_current_user),
):
    service = create_key_service(db)
    try:
        key = service.create_key(payload.name, payload.key, current_user.id)
        return KeyRead(
            id=key.id,
            owner_id=key.owner_id,
            name=key.name,
            created_at=key.created_at,
        )
    except DatabaseError:
        raise HTTPException(
            status_code=500, detail="An error occurred creating the key."
        )


@router.delete("/{id}", status_code=status.HTTP_204_NO_CONTENT)
def delete_key(
    id: UUID,
    db: Session = Depends(get_db),
    current_user: Profile = Depends(get_current_user),
):
    service = create_key_service(db)
    try:
        service.delete_key(id, current_user.id)
        return None
    except NotFoundError:
        raise HTTPException(status_code=404, detail="Key not found")