helpers.api_route_create(router, create_alert_tool)
#
# 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)
helpers.api_route_create(router, create_user_role)
#
# 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_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),
):
helpers.api_route_create(router, create_alert_type)
#
# 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)
helpers.api_route_create(router, create_event_prevention_tool)
#
# 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),
):
helpers.api_route_create(router, create_node_threat_actor)
#
# 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,
#
# 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),
):
helpers.api_route_create(router, create_analysis_module_type)
#
# 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),
):
helpers.api_route_create(router, create_disposition)
#
# 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_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),
):
helpers.api_route_create(router, create_event_risk_level)
#
# 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,
helpers.api_route_create(router, create_event_source)
#
# 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)
helpers.api_route_create(router, create_alert_queue)
#
# 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_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),
):
helpers.api_route_create(router, create_observable)
#
# 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
helpers.api_route_create(router, create_alert_tool_instance)
#
# 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,
#
# 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),
):
helpers.api_route_create(router, create_node_threat_type)
#
# 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,
helpers.api_route_create(router, create_node_threat)
#
# 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
#
# 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),
):