db_table=NodeComment,
db=db)
# Read the node from the database
db_node = crud.read(uuid=db_node_comment.node_uuid, db_table=Node, db=db)
# Set the new comment value
db_node_comment.value = node_comment.value
# Modifying the comment counts as modifying the node, so it should receive a new version
db_node.version = uuid4()
crud.commit(db)
response.headers["Content-Location"] = request.url_for("get_node_comment",
uuid=uuid)
helpers.api_route_update(router, update_node_comment)
#
# DELETE
#
def delete_node_comment(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=NodeComment, db=db)
helpers.api_route_delete(router, delete_node_comment)
# This counts as editing the analysis, so it should receive an updated version
db_analysis.version = uuid4()
if "redirection_uuid" in update_data:
db_observable_instance.redirection = crud.read(
uuid=update_data["redirection_uuid"],
db_table=ObservableInstance,
db=db)
# TODO: Figure out why setting the redirection field above does not set the redirection_uuid
# the same way it does in the create endpoint.
db_observable_instance.redirection_uuid = update_data[
"redirection_uuid"]
if "time" in update_data:
db_observable_instance.time = update_data["time"]
crud.commit(db)
response.headers["Content-Location"] = request.url_for(
"get_observable_instance", uuid=uuid)
helpers.api_route_update(router, update_observable_instance)
#
# DELETE
#
# We currently do not support deleting any Nodes.
if "tool" in update_data:
db_alert.tool = crud.read_by_value(value=update_data["tool"],
db_table=AlertTool,
db=db)
if "tool_instance" in update_data:
db_alert.tool_instance = crud.read_by_value(
value=update_data["tool_instance"],
db_table=AlertToolInstance,
db=db,
)
if "type" in update_data:
db_alert.type = crud.read_by_value(value=update_data["type"],
db_table=AlertType,
db=db)
crud.commit(db)
response.headers["Content-Location"] = request.url_for("get_alert",
uuid=uuid)
helpers.api_route_update(router, update_alert)
#
# DELETE
#
# We currently do not support deleting any Nodes.
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,
db_table=AlertToolInstance,
db=db)
response.headers["Content-Location"] = request.url_for(
"get_alert_tool_instance", uuid=uuid)
helpers.api_route_update(router, update_alert_tool_instance)
#
# DELETE
#
def delete_alert_tool_instance(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=AlertToolInstance, db=db)
helpers.api_route_delete(router, delete_alert_tool_instance)
#
# 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)
response.headers["Content-Location"] = request.url_for("get_alert_tool",
uuid=uuid)
helpers.api_route_update(router, update_alert_tool)
#
# DELETE
#
def delete_alert_tool(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=AlertTool, db=db)
helpers.api_route_delete(router, delete_alert_tool)
#
# 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)
response.headers["Content-Location"] = request.url_for("get_event_status", uuid=uuid)
helpers.api_route_update(router, update_event_status)
#
# DELETE
#
def delete_event_status(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=EventStatus, db=db)
helpers.api_route_delete(router, delete_event_status)
#
# 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)
response.headers["Content-Location"] = request.url_for("get_node_tag", uuid=uuid)
helpers.api_route_update(router, update_node_tag)
#
# DELETE
#
def delete_node_tag(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=NodeTag, db=db)
helpers.api_route_delete(router, delete_node_tag)
#
# 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)
response.headers["Content-Location"] = request.url_for("get_user_role",
uuid=uuid)
helpers.api_route_update(router, update_user_role)
#
# DELETE
#
def delete_user_role(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=UserRole, db=db)
helpers.api_route_delete(router, delete_user_role)
#
# 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)
response.headers["Content-Location"] = request.url_for("get_alert_queue",
uuid=uuid)
helpers.api_route_update(router, update_alert_queue)
#
# DELETE
#
def delete_alert_queue(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=AlertQueue, db=db)
helpers.api_route_delete(router, delete_alert_queue)
#
# 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)
response.headers["Content-Location"] = request.url_for("get_event_source",
uuid=uuid)
helpers.api_route_update(router, update_event_source)
#
# DELETE
#
def delete_event_source(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=EventSource, db=db)
helpers.api_route_delete(router, delete_event_source)
db=db)
if "status" in update_data:
db_event.status = crud.read_by_value(value=update_data["status"],
db_table=EventStatus,
db=db)
if "type" in update_data:
db_event.type = crud.read_by_value(value=update_data["type"],
db_table=EventType,
db=db)
if "vectors" in update_data:
db_event.vectors = crud.read_by_values(values=update_data["vectors"],
db_table=EventVector,
db=db)
crud.commit(db)
response.headers["Content-Location"] = request.url_for("get_event",
uuid=uuid)
helpers.api_route_update(router, update_event)
#
# DELETE
#
# We currently do not support deleting any Nodes.
#
# 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)
response.headers["Content-Location"] = request.url_for("get_event_remediation", uuid=uuid)
helpers.api_route_update(router, update_event_remediation)
#
# DELETE
#
def delete_event_remediation(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=EventRemediation, db=db)
helpers.api_route_delete(router, delete_event_remediation)
#
# 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)
response.headers["Content-Location"] = request.url_for("get_event_vector", uuid=uuid)
helpers.api_route_update(router, update_event_vector)
#
# DELETE
#
def delete_event_vector(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=EventVector, db=db)
helpers.api_route_delete(router, delete_event_vector)
#
# 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)
response.headers["Content-Location"] = request.url_for("get_alert_type",
uuid=uuid)
helpers.api_route_update(router, update_alert_type)
#
# DELETE
#
def delete_alert_type(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=AlertType, db=db)
helpers.api_route_delete(router, delete_alert_type)
uuid=update_data["analysis_module_type"],
db_table=AnalysisModuleType,
db=db)
db_analysis.analysis_module_type = db_analysis_module_type
if "details" in update_data:
db_analysis.details = update_data["details"]
if "error_message" in update_data:
db_analysis.error_message = update_data["error_message"]
if "stack_trace" in update_data:
db_analysis.stack_trace = update_data["stack_trace"]
if "summary" in update_data:
db_analysis.summary = update_data["summary"]
crud.commit(db)
response.headers["Content-Location"] = request.url_for("get_analysis",
uuid=uuid)
helpers.api_route_update(router, update_analysis)
#
# DELETE
#
# We currently do not support deleting any Nodes.
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,
db_table=EventPreventionTool,
db=db)
response.headers["Content-Location"] = request.url_for(
"get_event_prevention_tool", uuid=uuid)
helpers.api_route_update(router, update_event_prevention_tool)
#
# DELETE
#
def delete_event_prevention_tool(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=EventPreventionTool, db=db)
helpers.api_route_delete(router, delete_event_prevention_tool)
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,
db_table=EventRiskLevel,
db=db)
response.headers["Content-Location"] = request.url_for(
"get_event_risk_level", uuid=uuid)
helpers.api_route_update(router, update_event_risk_level)
#
# DELETE
#
def delete_event_risk_level(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=EventRiskLevel, db=db)
helpers.api_route_delete(router, delete_event_risk_level)
#
# 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)
response.headers["Content-Location"] = request.url_for("get_node_history_action", uuid=uuid)
helpers.api_route_update(router, update_node_history_action)
#
# DELETE
#
def delete_node_history_action(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=NodeHistoryAction, db=db)
helpers.api_route_delete(router, delete_node_history_action)
db_analysis_module_type.required_directives = crud.read_by_values(
values=update_data["required_directives"],
db_table=NodeDirective,
db=db)
if "required_tags" in update_data:
db_analysis_module_type.required_tags = crud.read_by_values(
values=update_data["required_tags"], db_table=NodeTag, db=db)
if "version" in update_data:
db_analysis_module_type.version = update_data["version"]
crud.commit(db)
response.headers["Content-Location"] = request.url_for(
"get_analysis_module_type", uuid=uuid)
helpers.api_route_update(router, update_analysis_module_type)
#
# DELETE
#
def delete_analysis_module_type(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=AnalysisModuleType, db=db)
helpers.api_route_delete(router, delete_analysis_module_type)
if "for_detection" in update_data:
db_observable.for_detection = update_data["for_detection"]
if "type" in update_data:
db_observable.type = crud.read_by_value(value=update_data["type"],
db_table=ObservableType,
db=db)
if "value" in update_data:
db_observable.value = update_data["value"]
crud.commit(db)
response.headers["Content-Location"] = request.url_for("get_observable",
uuid=uuid)
helpers.api_route_update(router, update_observable)
#
# DELETE
#
def delete_observable(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=Observable, db=db)
helpers.api_route_delete(router, delete_observable)
#
# 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)
response.headers["Content-Location"] = request.url_for("get_disposition",
uuid=uuid)
helpers.api_route_update(router, update_disposition)
#
# DELETE
#
def delete_disposition(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=AlertDisposition, db=db)
helpers.api_route_delete(router, delete_disposition)
if "description" in update_data:
db_node_threat.description = update_data["description"]
if "value" in update_data:
db_node_threat.value = update_data["value"]
if "types" in update_data:
db_node_threat.types = crud.read_by_values(values=update_data["types"],
db_table=NodeThreatType,
db=db)
crud.commit(db)
response.headers["Content-Location"] = request.url_for("get_node_threat",
uuid=uuid)
helpers.api_route_update(router, update_node_threat)
#
# DELETE
#
def delete_node_threat(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=NodeThreat, db=db)
helpers.api_route_delete(router, delete_node_threat)
#
# 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)
response.headers["Content-Location"] = request.url_for("get_event_type", uuid=uuid)
helpers.api_route_update(router, update_event_type)
#
# DELETE
#
def delete_event_type(uuid: UUID, db: Session = Depends(get_db)):
crud.delete(uuid=uuid, db_table=EventType, db=db)
helpers.api_route_delete(router, delete_event_type)
