# # 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)