#
# READ
#
# def get_all_alerts(db: Session = Depends(get_db)):
# return crud.read_all(db_table=Alert, db=db)
def get_alert(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=Alert, db=db)
# It does not make sense to have a get_all_alerts route at this point (and certainly not without pagination).
# helpers.api_route_read_all(router, get_all_alerts, List[AlertRead])
helpers.api_route_read(router, get_alert, AlertRead)
#
# UPDATE
#
def update_alert(
uuid: UUID,
alert: AlertUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
# Update the Node attributes
db_alert: Alert = update_node(node_update=alert,
#
# READ
#
# def get_all_node_directives(db: Session = Depends(get_db)):
# return crud.read_all(db_table=NodeDirective, db=db)
def get_node_comment(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=NodeComment, db=db)
# It does not make sense to have a get_all_node_comments route at this point (and certainly not without pagination).
# helpers.api_route_read_all(router, get_all_node_directives, List[NodeDirectiveRead])
helpers.api_route_read(router, get_node_comment, NodeCommentRead)
#
# UPDATE
#
def update_node_comment(
uuid: UUID,
node_comment: NodeCommentUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
# Read the current node comment from the database
db_node_comment: NodeComment = crud.read(uuid=uuid,
#
# READ
#
def get_all_observables(db: Session = Depends(get_db)):
return crud.read_all(db_table=Observable, db=db)
def get_observable(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=Observable, db=db)
helpers.api_route_read_all(router, get_all_observables, List[ObservableRead])
helpers.api_route_read(router, get_observable, ObservableRead)
#
# UPDATE
#
def update_observable(
uuid: UUID,
observable: ObservableUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
# Read the current observable from the database
db_observable: Observable = crud.read(uuid=uuid,
#
# READ
#
def get_all_node_threat_actors(db: Session = Depends(get_db)):
return crud.read_all(db_table=NodeThreatActor, db=db)
def get_node_threat_actor(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=NodeThreatActor, db=db)
helpers.api_route_read_all(router, get_all_node_threat_actors,
List[NodeThreatActorRead])
helpers.api_route_read(router, get_node_threat_actor, NodeThreatActorRead)
#
# UPDATE
#
def update_node_threat_actor(
uuid: UUID,
node_threat_actor: NodeThreatActorUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid,
obj=node_threat_actor,
#
# READ
#
def get_all_user_roles(db: Session = Depends(get_db)):
return crud.read_all(db_table=UserRole, db=db)
def get_user_role(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=UserRole, db=db)
helpers.api_route_read_all(router, get_all_user_roles, List[UserRoleRead])
helpers.api_route_read(router, get_user_role, UserRoleRead)
#
# UPDATE
#
def update_user_role(
uuid: UUID,
user_role: UserRoleUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=user_role, db_table=UserRole, db=db)
#
# READ
#
def get_all_observable_types(db: Session = Depends(get_db)):
return crud.read_all(db_table=ObservableType, db=db)
def get_observable_type(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=ObservableType, db=db)
helpers.api_route_read_all(router, get_all_observable_types,
List[ObservableTypeRead])
helpers.api_route_read(router, get_observable_type, ObservableTypeRead)
#
# UPDATE
#
def update_observable_type(
uuid: UUID,
observable_type: ObservableTypeUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=observable_type, db_table=ObservableType, db=db)
#
# READ
#
def get_all_node_tags(db: Session = Depends(get_db)):
return crud.read_all(db_table=NodeTag, db=db)
def get_node_tag(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=NodeTag, db=db)
helpers.api_route_read_all(router, get_all_node_tags, List[NodeTagRead])
helpers.api_route_read(router, get_node_tag, NodeTagRead)
#
# UPDATE
#
def update_node_tag(
uuid: UUID,
node_tag: NodeTagUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=node_tag, db_table=NodeTag, db=db)
#
# READ
#
def get_all_alert_types(db: Session = Depends(get_db)):
return crud.read_all(db_table=AlertType, db=db)
def get_alert_type(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=AlertType, db=db)
helpers.api_route_read_all(router, get_all_alert_types, List[AlertTypeRead])
helpers.api_route_read(router, get_alert_type, AlertTypeRead)
#
# UPDATE
#
def update_alert_type(
uuid: UUID,
alert_type: AlertTypeUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=alert_type, db_table=AlertType, db=db)
#
# READ
#
def get_all_alert_queues(db: Session = Depends(get_db)):
return crud.read_all(db_table=AlertQueue, db=db)
def get_alert_queue(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=AlertQueue, db=db)
helpers.api_route_read_all(router, get_all_alert_queues, List[AlertQueueRead])
helpers.api_route_read(router, get_alert_queue, AlertQueueRead)
#
# UPDATE
#
def update_alert_queue(
uuid: UUID,
alert_queue: AlertQueueUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=alert_queue, db_table=AlertQueue, db=db)
#
# READ
#
def get_all_event_sources(db: Session = Depends(get_db)):
return crud.read_all(db_table=EventSource, db=db)
def get_event_source(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=EventSource, db=db)
helpers.api_route_read_all(router, get_all_event_sources,
List[EventSourceRead])
helpers.api_route_read(router, get_event_source, EventSourceRead)
#
# UPDATE
#
def update_event_source(
uuid: UUID,
event_source: EventSourceUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=event_source, db_table=EventSource, db=db)
#
# READ
#
# def get_all_events(db: Session = Depends(get_db)):
# return crud.read_all(db_table=Event, db=db)
def get_event(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=Event, db=db)
# It does not make sense to have a get_all_events route at this point (and certainly not without pagination).
# helpers.api_route_read_all(router, get_all_events, List[EventRead])
helpers.api_route_read(router, get_event, EventRead)
#
# UPDATE
#
def update_event(
uuid: UUID,
event: EventUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
# Update the Node attributes
db_event: Event = update_node(node_update=event,
#
# READ
#
def get_all_event_remediations(db: Session = Depends(get_db)):
return crud.read_all(db_table=EventRemediation, db=db)
def get_event_remediation(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=EventRemediation, db=db)
helpers.api_route_read_all(router, get_all_event_remediations, List[EventRemediationRead])
helpers.api_route_read(router, get_event_remediation, EventRemediationRead)
#
# UPDATE
#
def update_event_remediation(
uuid: UUID,
event_remediation: EventRemediationUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=event_remediation, db_table=EventRemediation, db=db)
#
# READ
#
def get_all_event_vectors(db: Session = Depends(get_db)):
return crud.read_all(db_table=EventVector, db=db)
def get_event_vector(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=EventVector, db=db)
helpers.api_route_read_all(router, get_all_event_vectors, List[EventVectorRead])
helpers.api_route_read(router, get_event_vector, EventVectorRead)
#
# UPDATE
#
def update_event_vector(
uuid: UUID,
event_vector: EventVectorUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=event_vector, db_table=EventVector, db=db)
#
# READ
#
# def get_all_observable_instances(db: Session = Depends(get_db)):
# return crud.read_all(db_table=ObservableInstance, db=db)
def get_observable_instance(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=ObservableInstance, db=db)
# It does not make sense to have a get_all_observable_instances route at this point (and not without pagination).
# helpers.api_route_read_all(router, get_all_observable_instances, List[ObservableInstanceRead])
helpers.api_route_read(router, get_observable_instance, ObservableInstanceRead)
#
# UPDATE
#
def update_observable_instance(
uuid: UUID,
observable_instance: ObservableInstanceUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
# Update the Node attributes
db_observable_instance: ObservableInstance = update_node(
#
# READ
#
# def get_all_analysis(db: Session = Depends(get_db)):
# return crud.read_all(db_table=Analysis, db=db)
def get_analysis(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=Analysis, db=db)
# It does not make sense to have a get_all_analysis route at this point (and certainly not without pagination).
# helpers.api_route_read_all(router, get_all_analysis, List[AnalysisRead])
helpers.api_route_read(router, get_analysis, AnalysisRead)
#
# UPDATE
#
def update_analysis(
uuid: UUID,
analysis: AnalysisUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
# Update the Node attributes
db_analysis: Analysis = update_node(node_update=analysis,
#
# READ
#
def get_all_node_threat_types(db: Session = Depends(get_db)):
return crud.read_all(db_table=NodeThreatType, db=db)
def get_node_threat_type(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=NodeThreatType, db=db)
helpers.api_route_read_all(router, get_all_node_threat_types,
List[NodeThreatTypeRead])
helpers.api_route_read(router, get_node_threat_type, NodeThreatTypeRead)
#
# UPDATE
#
def update_node_threat_type(
uuid: UUID,
node_threat_type: NodeThreatTypeUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid,
obj=node_threat_type,
#
# READ
#
def get_all_event_risk_levels(db: Session = Depends(get_db)):
return crud.read_all(db_table=EventRiskLevel, db=db)
def get_event_risk_level(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=EventRiskLevel, db=db)
helpers.api_route_read_all(router, get_all_event_risk_levels,
List[EventRiskLevelRead])
helpers.api_route_read(router, get_event_risk_level, EventRiskLevelRead)
#
# UPDATE
#
def update_event_risk_level(
uuid: UUID,
event_risk_level: EventRiskLevelUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid,
obj=event_risk_level,
#
# READ
#
def get_all_event_prevention_tools(db: Session = Depends(get_db)):
return crud.read_all(db_table=EventPreventionTool, db=db)
def get_event_prevention_tool(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=EventPreventionTool, db=db)
helpers.api_route_read_all(router, get_all_event_prevention_tools,
List[EventPreventionToolRead])
helpers.api_route_read(router, get_event_prevention_tool,
EventPreventionToolRead)
#
# UPDATE
#
def update_event_prevention_tool(
uuid: UUID,
event_prevention_tool: EventPreventionToolUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid,
obj=event_prevention_tool,
#
# READ
#
def get_all_analysis_module_types(db: Session = Depends(get_db)):
return crud.read_all(db_table=AnalysisModuleType, db=db)
def get_analysis_module_type(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=AnalysisModuleType, db=db)
helpers.api_route_read_all(router, get_all_analysis_module_types,
List[AnalysisModuleTypeRead])
helpers.api_route_read(router, get_analysis_module_type,
AnalysisModuleTypeRead)
#
# UPDATE
#
def update_analysis_module_type(
uuid: UUID,
analysis_module_type: AnalysisModuleTypeUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
# Read the current analysis module type from the database
db_analysis_module_type: AnalysisModuleType = crud.read(
#
# READ
#
def get_all_node_history_actions(db: Session = Depends(get_db)):
return crud.read_all(db_table=NodeHistoryAction, db=db)
def get_node_history_action(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=NodeHistoryAction, db=db)
helpers.api_route_read_all(router, get_all_node_history_actions, List[NodeHistoryActionRead])
helpers.api_route_read(router, get_node_history_action, NodeHistoryActionRead)
#
# UPDATE
#
def update_node_history_action(
uuid: UUID,
node_history_action: NodeHistoryActionUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=node_history_action, db_table=NodeHistoryAction, db=db)
#
# READ
#
def get_all_dispositions(db: Session = Depends(get_db)):
return crud.read_all(db_table=AlertDisposition, db=db)
def get_disposition(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=AlertDisposition, db=db)
helpers.api_route_read_all(router, get_all_dispositions,
List[AlertDispositionRead])
helpers.api_route_read(router, get_disposition, AlertDispositionRead)
#
# UPDATE
#
def update_disposition(
uuid: UUID,
disposition: AlertDispositionUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=disposition, db_table=AlertDisposition, db=db)
#
# READ
#
def get_all_alert_tools(db: Session = Depends(get_db)):
return crud.read_all(db_table=AlertTool, db=db)
def get_alert_tool(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=AlertTool, db=db)
helpers.api_route_read_all(router, get_all_alert_tools, List[AlertToolRead])
helpers.api_route_read(router, get_alert_tool, AlertToolRead)
#
# UPDATE
#
def update_alert_tool(
uuid: UUID,
alert_tool: AlertToolUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=alert_tool, db_table=AlertTool, db=db)
#
# READ
#
def get_all_users(db: Session = Depends(get_db)):
return crud.read_all(db_table=User, db=db)
def get_user(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=User, db=db)
helpers.api_route_read_all(router, get_all_users, List[UserRead])
helpers.api_route_read(router, get_user, UserRead)
#
# UPDATE
#
def update_user(
uuid: UUID,
user: UserUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
# Read the current user from the database
db_user: User = crud.read(uuid=uuid, db_table=User, db=db)
#
# READ
#
def get_all_event_statuses(db: Session = Depends(get_db)):
return crud.read_all(db_table=EventStatus, db=db)
def get_event_status(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=EventStatus, db=db)
helpers.api_route_read_all(router, get_all_event_statuses, List[EventStatusRead])
helpers.api_route_read(router, get_event_status, EventStatusRead)
#
# UPDATE
#
def update_event_status(
uuid: UUID,
event_status: EventStatusUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=event_status, db_table=EventStatus, db=db)
#
# READ
#
def get_all_alert_tool_instances(db: Session = Depends(get_db)):
return crud.read_all(db_table=AlertToolInstance, db=db)
def get_alert_tool_instance(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=AlertToolInstance, db=db)
helpers.api_route_read_all(router, get_all_alert_tool_instances,
List[AlertToolInstanceRead])
helpers.api_route_read(router, get_alert_tool_instance, AlertToolInstanceRead)
#
# UPDATE
#
def update_alert_tool_instance(
uuid: UUID,
alert_tool_instance: AlertToolInstanceUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid,
obj=alert_tool_instance,
#
# READ
#
def get_all_node_threats(db: Session = Depends(get_db)):
return crud.read_all(db_table=NodeThreat, db=db)
def get_node_threat(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=NodeThreat, db=db)
helpers.api_route_read_all(router, get_all_node_threats, List[NodeThreatRead])
helpers.api_route_read(router, get_node_threat, NodeThreatRead)
#
# UPDATE
#
def update_node_threat(
uuid: UUID,
node_threat: NodeThreatUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
# Read the current node threat from the database
db_node_threat: NodeThreat = crud.read(uuid=uuid,
#
# READ
#
def get_all_event_types(db: Session = Depends(get_db)):
return crud.read_all(db_table=EventType, db=db)
def get_event_type(uuid: UUID, db: Session = Depends(get_db)):
return crud.read(uuid=uuid, db_table=EventType, db=db)
helpers.api_route_read_all(router, get_all_event_types, List[EventTypeRead])
helpers.api_route_read(router, get_event_type, EventTypeRead)
#
# UPDATE
#
def update_event_type(
uuid: UUID,
event_type: EventTypeUpdate,
request: Request,
response: Response,
db: Session = Depends(get_db),
):
crud.update(uuid=uuid, obj=event_type, db_table=EventType, db=db)
