8
from fastapi import File
9
from fastapi import HTTPException
10
from fastapi import Query
11
+from fastapi import Security
12
from fastapi import UploadFile
13
from fastapi.responses import StreamingResponse
14
from loguru import logger
241
incidents_db_operations_router = APIRouter()
242
243
243
-@incidents_db_operations_router.get("/ai_trigger/{customer_code}", response_model=AITriggerResponse)
244
+@incidents_db_operations_router.get(
245
+ "/ai_trigger/{customer_code}",
246
+ response_model=AITriggerResponse,
247
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
248
+)
249
async def get_customer_ai_trigger_endpoint(
250
customer_code: str,
251
_customer: Customers = Depends(check_customer_exists),
258
)
259
260
256
-@incidents_db_operations_router.put("/ai_trigger", response_model=AITriggerResponse)
261
+@incidents_db_operations_router.put(
262
+ "/ai_trigger",
263
+ response_model=AITriggerResponse,
264
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
265
+)
266
async def put_customer_ai_trigger_endpoint(
267
notification: PutAITrigger,
268
_customer: Customers = Depends(check_customer_exists),
276
)
277
278
270
-@incidents_db_operations_router.get("/notification/{customer_code}", response_model=NotificationResponse)
279
+@incidents_db_operations_router.get(
280
+ "/notification/{customer_code}",
281
+ response_model=NotificationResponse,
282
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
283
+)
284
async def get_customer_notification_endpoint(
285
customer_code: str,
286
_customer: Customers = Depends(check_customer_exists),
293
)
294
295
283
-@incidents_db_operations_router.put("/notification", response_model=NotificationResponse)
296
+@incidents_db_operations_router.put(
297
+ "/notification",
298
+ response_model=NotificationResponse,
299
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
300
+)
301
async def put_customer_notification_endpoint(
302
notification: PutNotification,
303
_customer: Customers = Depends(check_customer_exists),
311
)
312
313
297
-@incidents_db_operations_router.get("/available-source/{index_name}", response_model=AvailableSourcesResponse)
314
+@incidents_db_operations_router.get(
315
+ "/available-source/{index_name}",
316
+ response_model=AvailableSourcesResponse,
317
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
318
+)
319
async def get_available_source_values(index_name: str, session: AsyncSession = Depends(get_db)):
320
return AvailableSourcesResponse(source=await get_index_source(index_name), success=True, message="Source retrieved successfully")
321
322
302
-@incidents_db_operations_router.get("/available-indices/{source}", response_model=AvailableIndicesResponse)
323
+@incidents_db_operations_router.get(
324
+ "/available-indices/{source}",
325
+ response_model=AvailableIndicesResponse,
326
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
327
+)
328
async def get_available_indices(source: str, session: AsyncSession = Depends(get_db)):
329
return AvailableIndicesResponse(
330
indices=await get_available_indices_via_source(source),
333
)
334
335
311
-@incidents_db_operations_router.get("/socfortress/recommends/wazuh", response_model=SocfortressRecommendsWazuhResponse)
336
+@incidents_db_operations_router.get(
337
+ "/socfortress/recommends/wazuh",
338
+ response_model=SocfortressRecommendsWazuhResponse,
339
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
340
+)
341
async def get_socfortress_recommends_wazuh(session: AsyncSession = Depends(get_db)):
342
return SocfortressRecommendsWazuhResponse(
343
field_names=[field.value for field in SocfortressRecommendsWazuhFieldNames],
351
)
352
353
325
-@incidents_db_operations_router.get("/configured/sources", response_model=ConfiguredSourcesResponse)
354
+@incidents_db_operations_router.get(
355
+ "/configured/sources",
356
+ response_model=ConfiguredSourcesResponse,
357
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
358
+)
359
async def get_configured_sources(session: AsyncSession = Depends(get_db)):
360
query = select(FieldName.source).distinct()
361
result = await session.execute(query)
362
return ConfiguredSourcesResponse(sources=[row[0] for row in result], success=True, message="Configured sources retrieved successfully")
363
364
332
-@incidents_db_operations_router.delete("/configured/sources/{source}")
365
+@incidents_db_operations_router.delete(
366
+ "/configured/sources/{source}",
367
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
368
+)
369
async def delete_configured_source(source: str, session: AsyncSession = Depends(get_db)):
370
# Fully deletes the configured sources `field_names`, `asset_name`, timefield_name`, alert_title_name`
371
field_names = await get_field_names(source, session)
398
return {"message": f"Configured source {source} deleted successfully", "success": True}
399
400
365
-@incidents_db_operations_router.get("/mappings/fields-assets-title-and-timefield", response_model=MappingsResponse)
401
+@incidents_db_operations_router.get(
402
+ "/mappings/fields-assets-title-and-timefield",
403
+ response_model=MappingsResponse,
404
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
405
+)
406
async def get_wazuh_fields_and_assets(index_name: str, session: AsyncSession = Depends(get_db)):
407
index_mapping = await get_index_mappings_key_names(index_name)
408
return MappingsResponse(available_mappings=index_mapping, success=True, message="Field names and asset names retrieved successfully")
409
410
371
-@incidents_db_operations_router.get("/fields-assets-title-and-timefield", response_model=FieldAndAssetNamesResponse)
411
+@incidents_db_operations_router.get(
412
+ "/fields-assets-title-and-timefield",
413
+ response_model=FieldAndAssetNamesResponse,
414
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
415
+)
416
async def get_source_fields_and_assets(source: str, session: AsyncSession = Depends(get_db)):
417
await validate_source_exists(source, session)
418
return FieldAndAssetNamesResponse(
427
)
428
429
386
-@incidents_db_operations_router.post("/fields-assets-title-and-timefield")
430
+@incidents_db_operations_router.post(
431
+ "/fields-assets-title-and-timefield",
432
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
433
+)
434
async def create_wazuh_fields_and_assets(names: FieldAndAssetNames, session: AsyncSession = Depends(get_db)):
435
for field_name in names.field_names:
436
await add_field_name(names.source, field_name, session)
452
return {"message": "Field names and asset names created successfully", "success": True}
453
454
408
-@incidents_db_operations_router.put("/fields-assets-title-and-timefield")
455
+@incidents_db_operations_router.put(
456
+ "/fields-assets-title-and-timefield",
457
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
458
+)
459
async def update_fields_and_assets(names: FieldAndAssetNames, session: AsyncSession = Depends(get_db)):
460
await replace_field_name(names.source, names.field_names, session)
461
470
return {"message": "Field names and asset names created successfully", "success": True}
471
472
423
-@incidents_db_operations_router.delete("/delete-fields-assets-title-and-timefield")
473
+@incidents_db_operations_router.delete(
474
+ "/delete-fields-assets-title-and-timefield",
475
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
476
+)
477
async def delete_wazuh_fields_and_assets(names: FieldAndAssetNames, session: AsyncSession = Depends(get_db)):
478
for field_name in names.field_names:
479
await delete_field_name(names.source, field_name, session)
494
return {"message": "Field names and asset names deleted successfully", "success": True}
495
496
444
-@incidents_db_operations_router.delete("/field_name/{field_name}/{source}", deprecated=True)
497
+@incidents_db_operations_router.delete(
498
+ "/field_name/{field_name}/{source}",
499
+ deprecated=True,
500
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
501
+)
502
async def delete_field_name_endpoint(field_name: str, source: str, db: AsyncSession = Depends(get_db)):
503
return await delete_field_name(source, field_name, db)
504
505
449
-@incidents_db_operations_router.delete("/asset_name/{asset_name}/{source}", deprecated=True)
506
+@incidents_db_operations_router.delete(
507
+ "/asset_name/{asset_name}/{source}",
508
+ deprecated=True,
509
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
510
+)
511
async def delete_asset_name_endpoint(asset_name: str, source: str, db: AsyncSession = Depends(get_db)):
512
return await delete_asset_name(source, asset_name, db)
513
514
454
-@incidents_db_operations_router.delete("/timefield_name/{timefield_name}/{source}", deprecated=True)
515
+@incidents_db_operations_router.delete(
516
+ "/timefield_name/{timefield_name}/{source}",
517
+ deprecated=True,
518
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
519
+)
520
async def delete_timefield_name_endpoint(timefield_name: str, source: str, db: AsyncSession = Depends(get_db)):
521
return await delete_timefield_name(source, timefield_name, db)
522
523
459
-@incidents_db_operations_router.delete("/alert_title_name/{alert_title_name}/{source}", deprecated=True)
524
+@incidents_db_operations_router.delete(
525
+ "/alert_title_name/{alert_title_name}/{source}",
526
+ deprecated=True,
527
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
528
+)
529
async def delete_alert_title_name_endpoint(alert_title_name: str, source: str, db: AsyncSession = Depends(get_db)):
530
return await delete_alert_title_name(source, alert_title_name, db)
531
532
464
-@incidents_db_operations_router.post("/alert", response_model=Alert)
533
+@incidents_db_operations_router.post(
534
+ "/alert",
535
+ response_model=Alert,
536
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
537
+)
538
async def create_alert_endpoint(alert: AlertCreate, db: AsyncSession = Depends(get_db)):
539
return await create_alert(alert, db)
540
541
469
-@incidents_db_operations_router.put("/alert/status", response_model=AlertResponse)
542
+@incidents_db_operations_router.put(
543
+ "/alert/status",
544
+ response_model=AlertResponse,
545
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
546
+)
547
async def update_alert_status_endpoint(alert_status: UpdateAlertStatus, db: AsyncSession = Depends(get_db)):
548
return AlertResponse(alert=await update_alert_status(alert_status, db), success=True, message="Alert status updated successfully")
549
550
474
-@incidents_db_operations_router.put("/alert/escalated", response_model=AlertResponse)
551
+@incidents_db_operations_router.put(
552
+ "/alert/escalated",
553
+ response_model=AlertResponse,
554
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
555
+)
556
async def update_alert_escalated_endpoint(
557
escalate_alert: EscalateAlert,
558
current_user: User = Depends(AuthHandler().get_current_user),
574
return AlertResponse(alert=updated_alert, success=True, message="Alert escalated status updated successfully")
575
576
496
-@incidents_db_operations_router.post("/alert/comment", response_model=CommentResponse)
577
+@incidents_db_operations_router.post(
578
+ "/alert/comment",
579
+ response_model=CommentResponse,
580
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
581
+)
582
async def create_comment_endpoint(
583
comment: CommentCreate,
584
current_user: User = Depends(AuthHandler().get_current_user),
594
return CommentResponse(comment=await create_comment(comment, db), success=True, message="Comment created successfully")
595
596
512
-@incidents_db_operations_router.put("/alert/comment", response_model=CommentResponse)
597
+@incidents_db_operations_router.put(
598
+ "/alert/comment",
599
+ response_model=CommentResponse,
600
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
601
+)
602
async def edit_comment_endpoint(
603
comment: CommentEdit,
604
current_user: User = Depends(AuthHandler().get_current_user),
614
return CommentResponse(comment=await edit_comment(comment, db), success=True, message="Comment edited successfully")
615
616
528
-@incidents_db_operations_router.delete("/alert/comment/{comment_id}")
617
+@incidents_db_operations_router.delete(
618
+ "/alert/comment/{comment_id}",
619
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
620
+)
621
async def delete_comment_endpoint(
622
comment_id: int,
623
current_user: User = Depends(AuthHandler().get_current_user),
643
return {"message": "Comment deleted successfully", "success": True}
644
645
554
-@incidents_db_operations_router.post("/case/comment", response_model=CaseCommentResponse)
646
+@incidents_db_operations_router.post(
647
+ "/case/comment",
648
+ response_model=CaseCommentResponse,
649
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
650
+)
651
async def create_case_comment_endpoint(
652
comment: CaseCommentCreate,
653
current_user: User = Depends(AuthHandler().get_current_user),
663
return CaseCommentResponse(comment=await create_case_comment(comment, db), success=True, message="Case comment created successfully")
664
665
570
-@incidents_db_operations_router.put("/case/comment", response_model=CaseCommentResponse)
666
+@incidents_db_operations_router.put(
667
+ "/case/comment",
668
+ response_model=CaseCommentResponse,
669
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
670
+)
671
async def edit_case_comment_endpoint(
672
comment: CaseCommentEdit,
673
current_user: User = Depends(AuthHandler().get_current_user),
683
return CaseCommentResponse(comment=await edit_case_comment(comment, db), success=True, message="Case comment edited successfully")
684
685
586
-@incidents_db_operations_router.delete("/case/comment/{comment_id}")
686
+@incidents_db_operations_router.delete(
687
+ "/case/comment/{comment_id}",
688
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
689
+)
690
async def delete_case_comment_endpoint(
691
comment_id: int,
692
current_user: User = Depends(AuthHandler().get_current_user),
712
return {"message": "Case comment deleted successfully", "success": True}
713
714
612
-@incidents_db_operations_router.get("/alert/available-users", response_model=AvailableUsersResponse)
715
+@incidents_db_operations_router.get(
716
+ "/alert/available-users",
717
+ response_model=AvailableUsersResponse,
718
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
719
+)
720
async def get_available_users(db: AsyncSession = Depends(get_db)):
721
all_users = await select_all_users()
722
return AvailableUsersResponse(
726
)
727
728
622
-@incidents_db_operations_router.put("/alert/assigned-to", response_model=AlertResponse)
729
+@incidents_db_operations_router.put(
730
+ "/alert/assigned-to",
731
+ response_model=AlertResponse,
732
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
733
+)
734
async def update_assigned_to_endpoint(assigned_to: AssignedToAlert, db: AsyncSession = Depends(get_db)):
735
all_users = await select_all_users()
736
user_names = [user.username for user in all_users]
743
)
744
745
635
-@incidents_db_operations_router.post("/alert/context", response_model=AlertContextResponse)
746
+@incidents_db_operations_router.post(
747
+ "/alert/context",
748
+ response_model=AlertContextResponse,
749
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
750
+)
751
async def create_alert_context_endpoint(alert_context: AlertContextCreate, db: AsyncSession = Depends(get_db)):
752
return AlertContextResponse(
753
alert_context=await create_alert_context(alert_context, db),
756
)
757
758
644
-@incidents_db_operations_router.get("/alert/context/{alert_context_id}", response_model=AlertContextResponse)
759
+@incidents_db_operations_router.get(
760
+ "/alert/context/{alert_context_id}",
761
+ response_model=AlertContextResponse,
762
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
763
+)
764
async def get_alert_context_by_id_endpoint(alert_context_id: int, db: AsyncSession = Depends(get_db)):
765
return AlertContextResponse(
766
alert_context=await get_alert_context_by_id(alert_context_id, db),
769
)
770
771
653
-@incidents_db_operations_router.post("/alert/asset", response_model=AssetResponse)
772
+@incidents_db_operations_router.post(
773
+ "/alert/asset",
774
+ response_model=AssetResponse,
775
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
776
+)
777
async def create_asset_endpoint(asset: AssetCreate, db: AsyncSession = Depends(get_db)):
778
return AssetResponse(asset=await create_asset(asset, db), success=True, message="Asset created successfully")
779
780
658
-@incidents_db_operations_router.post("/alert/ioc", response_model=AlertIoCResponse)
781
+@incidents_db_operations_router.post(
782
+ "/alert/ioc",
783
+ response_model=AlertIoCResponse,
784
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
785
+)
786
async def create_alert_ioc_endpoint(ioc: AlertIoCCreate, db: AsyncSession = Depends(get_db)):
787
return AlertIoCResponse(alert_ioc=await create_alert_ioc(ioc, db), success=True, message="Alert IoC created successfully")
788
789
663
-@incidents_db_operations_router.get("/alert/ioc/{ioc_value}", response_model=AlertOutResponse)
790
+@incidents_db_operations_router.get(
791
+ "/alert/ioc/{ioc_value}",
792
+ response_model=AlertOutResponse,
793
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
794
+)
795
async def list_alerts_by_ioc_value_endpoint(
796
ioc_value: str,
797
page: int = Query(1, ge=1),
838
)
839
840
710
-@incidents_db_operations_router.delete("/alert/ioc", response_model=AlertIoCResponse)
841
+@incidents_db_operations_router.delete(
842
+ "/alert/ioc",
843
+ response_model=AlertIoCResponse,
844
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
845
+)
846
async def delete_alert_ioc_endpoint(ioc: AlertIoCDelete, db: AsyncSession = Depends(get_db)):
847
return AlertIoCResponse(
848
alert_ioc=await delete_alert_ioc(ioc=ioc, db=db),
851
)
852
853
719
-@incidents_db_operations_router.post("/alert/tag", response_model=AlertTagResponse)
854
+@incidents_db_operations_router.post(
855
+ "/alert/tag",
856
+ response_model=AlertTagResponse,
857
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
858
+)
859
async def create_alert_tag_endpoint(alert_tag: AlertTagCreate, db: AsyncSession = Depends(get_db)):
860
return AlertTagResponse(alert_tag=await create_alert_tag(alert_tag, db), success=True, message="Alert tag created successfully")
861
862
724
-@incidents_db_operations_router.get("/alert/tag/{tag}", response_model=AlertOutResponse)
863
+@incidents_db_operations_router.get(
864
+ "/alert/tag/{tag}",
865
+ response_model=AlertOutResponse,
866
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
867
+)
868
async def list_alerts_by_tag_endpoint(
869
tag: str,
870
page: int = Query(1, ge=1),
911
)
912
913
771
-@incidents_db_operations_router.delete("/alert/tag", response_model=AlertTagResponse)
914
+@incidents_db_operations_router.delete(
915
+ "/alert/tag",
916
+ response_model=AlertTagResponse,
917
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
918
+)
919
async def delete_alert_tag_endpoint(alert_tag: AlertTagDelete, db: AsyncSession = Depends(get_db)):
920
return AlertTagResponse(
921
alert_tag=await delete_alert_tag(alert_tag.alert_id, alert_tag.tag_id, db),
924
)
925
926
780
-@incidents_db_operations_router.post("/case/create", response_model=CaseResponse)
927
+@incidents_db_operations_router.post(
928
+ "/case/create",
929
+ response_model=CaseResponse,
930
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
931
+)
932
async def create_case_endpoint(case: CaseCreate, db: AsyncSession = Depends(get_db)):
933
return CaseResponse(case=await create_case(case, db), success=True, message="Case created successfully")
934
935
785
-@incidents_db_operations_router.post("/case/alert-link", response_model=CaseAlertLinkResponse)
936
+@incidents_db_operations_router.post(
937
+ "/case/alert-link",
938
+ response_model=CaseAlertLinkResponse,
939
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
940
+)
941
async def create_case_alert_link_endpoint(case_alert_link: CaseAlertLinkCreate, db: AsyncSession = Depends(get_db)):
942
return CaseAlertLinkResponse(
943
case_alert_link=await create_case_alert_link(case_alert_link, db),
946
)
947
948
794
-@incidents_db_operations_router.post("/case/alert-links", response_model=CaseAlertLinksResponse)
949
+@incidents_db_operations_router.post(
950
+ "/case/alert-links",
951
+ response_model=CaseAlertLinksResponse,
952
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
953
+)
954
async def create_case_alert_links_endpoint(case_alert_links: CaseAlertLinksCreate, db: AsyncSession = Depends(get_db)):
955
return CaseAlertLinksResponse(
956
case_alert_links=await create_case_alert_links_bulk(case_alert_links, db),
959
)
960
961
803
-@incidents_db_operations_router.post("/case/alert-unlink", response_model=CaseAlertUnLinkResponse)
962
+@incidents_db_operations_router.post(
963
+ "/case/alert-unlink",
964
+ response_model=CaseAlertUnLinkResponse,
965
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
966
+)
967
async def case_alert_unlink_endpoint(case_alert_link: CaseAlertUnLink, db: AsyncSession = Depends(get_db)):
968
return await case_alert_unlink(case_alert_link, db)
969
970
808
-@incidents_db_operations_router.post("/case/from-alert", response_model=CaseAlertLinkResponse)
971
+@incidents_db_operations_router.post(
972
+ "/case/from-alert",
973
+ response_model=CaseAlertLinkResponse,
974
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
975
+)
976
async def create_case_from_alert_endpoint(alert_id: CaseCreateFromAlert, db: AsyncSession = Depends(get_db)):
977
case = await create_case_from_alert(alert_id.alert_id, db)
978
if case is None:
984
)
985
986
820
-@incidents_db_operations_router.get("/alerts/filter-options", response_model=AlertFilterOptionsResponse)
987
+@incidents_db_operations_router.get(
988
+ "/alerts/filter-options",
989
+ response_model=AlertFilterOptionsResponse,
990
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
991
+)
992
async def get_alert_filter_options_endpoint(
993
current_user: User = Depends(AuthHandler().get_current_user),
994
db: AsyncSession = Depends(get_db),
1004
)
1005
1006
836
-@incidents_db_operations_router.get("/cases/filter-options", response_model=CaseFilterOptionsResponse)
1007
+@incidents_db_operations_router.get(
1008
+ "/cases/filter-options",
1009
+ response_model=CaseFilterOptionsResponse,
1010
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1011
+)
1012
async def get_case_filter_options_endpoint(
1013
current_user: User = Depends(AuthHandler().get_current_user),
1014
db: AsyncSession = Depends(get_db),
1040
)
1041
1042
868
-@incidents_db_operations_router.get("/alerts", response_model=AlertOutResponse)
1043
+@incidents_db_operations_router.get(
1044
+ "/alerts",
1045
+ response_model=AlertOutResponse,
1046
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1047
+)
1048
async def list_alerts_endpoint(
1049
page: int = Query(1, ge=1),
1050
page_size: int = Query(25, ge=1),
1074
)
1075
1076
898
-@incidents_db_operations_router.get("/alert/{alert_id}", response_model=AlertOutResponse)
1077
+@incidents_db_operations_router.get(
1078
+ "/alert/{alert_id}",
1079
+ response_model=AlertOutResponse,
1080
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1081
+)
1082
async def get_alert_by_id_endpoint(
1083
alert_id: int,
1084
current_user: User = Depends(AuthHandler().get_current_user),
1097
return AlertOutResponse(alerts=[alert], success=True, message="Alert retrieved successfully")
1098
1099
917
-@incidents_db_operations_router.delete("/alert/{alert_id}")
1100
+@incidents_db_operations_router.delete(
1101
+ "/alert/{alert_id}",
1102
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1103
+)
1104
async def delete_alert_endpoint(
1105
alert_id: int,
1106
current_user: User = Depends(AuthHandler().get_current_user),
1121
return {"message": "Alert deleted successfully", "success": True}
1122
1123
938
-@incidents_db_operations_router.delete("/alerts", response_model=DeleteAlertsResponse)
1124
+@incidents_db_operations_router.delete(
1125
+ "/alerts",
1126
+ response_model=DeleteAlertsResponse,
1127
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1128
+)
1129
async def delete_alerts_endpoint(request: DeleteAlertsRequest, db: AsyncSession = Depends(get_db)):
1130
"""
1131
Endpoint to delete alerts.
1163
)
1164
1165
976
-@incidents_db_operations_router.delete("/alerts/by-title/{title_filter}", response_model=DeleteAlertsResponse)
1166
+@incidents_db_operations_router.delete(
1167
+ "/alerts/by-title/{title_filter}",
1168
+ response_model=DeleteAlertsResponse,
1169
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1170
+)
1171
async def delete_alerts_by_title_endpoint(
1172
title_filter: str,
1173
current_user: User = Depends(AuthHandler().get_current_user),
1235
)
1236
1237
1044
-@incidents_db_operations_router.get("/alerts/status/{status}", response_model=AlertOutResponse)
1238
+@incidents_db_operations_router.get(
1239
+ "/alerts/status/{status}",
1240
+ response_model=AlertOutResponse,
1241
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1242
+)
1243
async def list_alerts_by_status_endpoint(
1244
status: AlertStatus,
1245
page: int = Query(1, ge=1),
1292
)
1293
1294
1097
-@incidents_db_operations_router.get("/alerts/assigned-to/{assigned_to}", response_model=AlertOutResponse)
1295
+@incidents_db_operations_router.get(
1296
+ "/alerts/assigned-to/{assigned_to}",
1297
+ response_model=AlertOutResponse,
1298
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1299
+)
1300
async def list_alerts_by_assigned_to_endpoint(
1301
assigned_to: str,
1302
page: int = Query(1, ge=1),
1344
)
1345
1346
1145
-@incidents_db_operations_router.get("/alerts/asset/{asset_name}", response_model=AlertOutResponse)
1347
+@incidents_db_operations_router.get(
1348
+ "/alerts/asset/{asset_name}",
1349
+ response_model=AlertOutResponse,
1350
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1351
+)
1352
async def list_alerts_by_asset_name_endpoint(
1353
asset_name: str,
1354
page: int = Query(1, ge=1),
1396
)
1397
1398
1193
-@incidents_db_operations_router.get("/alerts/title/{title}", response_model=AlertOutResponse)
1399
+@incidents_db_operations_router.get(
1400
+ "/alerts/title/{title}",
1401
+ response_model=AlertOutResponse,
1402
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1403
+)
1404
async def list_alerts_by_title_endpoint(
1405
title: str,
1406
page: int = Query(1, ge=1),
1448
)
1449
1450
1241
-@incidents_db_operations_router.get("/alerts/customer/{customer_code}", response_model=AlertOutResponse)
1451
+@incidents_db_operations_router.get(
1452
+ "/alerts/customer/{customer_code}",
1453
+ response_model=AlertOutResponse,
1454
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1455
+)
1456
async def list_alerts_by_customer_code_endpoint(
1457
customer_code: str,
1458
page: int = Query(1, ge=1),
1477
)
1478
1479
1266
-@incidents_db_operations_router.get("/alerts/source/{source}", response_model=AlertOutResponse)
1480
+@incidents_db_operations_router.get(
1481
+ "/alerts/source/{source}",
1482
+ response_model=AlertOutResponse,
1483
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1484
+)
1485
async def list_alerts_by_source_endpoint(
1486
source: str,
1487
page: int = Query(1, ge=1),
1529
)
1530
1531
1314
-@incidents_db_operations_router.get("/alerts/filter", response_model=AlertOutResponse)
1532
+@incidents_db_operations_router.get(
1533
+ "/alerts/filter",
1534
+ response_model=AlertOutResponse,
1535
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1536
+)
1537
async def list_alerts_multiple_filters_endpoint(
1538
assigned_to: Optional[str] = Query(None),
1539
alert_title: Optional[str] = Query(None),
1615
)
1616
1617
1396
-@incidents_db_operations_router.get("/cases", response_model=CaseOutResponse)
1618
+@incidents_db_operations_router.get(
1619
+ "/cases",
1620
+ response_model=CaseOutResponse,
1621
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1622
+)
1623
async def list_cases_endpoint(
1624
page: int = Query(1, ge=1),
1625
page_size: int = Query(25, ge=1),
1648
)
1649
1650
1425
-@incidents_db_operations_router.put("/case/status", response_model=CaseOutResponse)
1651
+@incidents_db_operations_router.put(
1652
+ "/case/status",
1653
+ response_model=CaseOutResponse,
1654
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1655
+)
1656
async def update_case_status_endpoint(
1657
case_status: UpdateCaseStatus,
1658
current_user: User = Depends(AuthHandler().get_current_user),
1746
return CaseOutResponse(cases=[updated_case], success=True, message=message)
1747
1748
1519
-@incidents_db_operations_router.put("/case/escalated", response_model=CaseOutResponse)
1749
+@incidents_db_operations_router.put(
1750
+ "/case/escalated",
1751
+ response_model=CaseOutResponse,
1752
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1753
+)
1754
async def update_case_escalated_endpoint(
1755
escalate_case: EscalateCase,
1756
current_user: User = Depends(AuthHandler().get_current_user),
1776
return CaseOutResponse(cases=[updated_case], success=True, message="Case escalated status updated successfully")
1777
1778
1545
-@incidents_db_operations_router.put("/case/assigned-to", response_model=CaseOutResponse)
1779
+@incidents_db_operations_router.put(
1780
+ "/case/assigned-to",
1781
+ response_model=CaseOutResponse,
1782
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1783
+)
1784
async def update_case_assigned_to_endpoint(
1785
assigned_to: AssignedToCase,
1786
current_user: User = Depends(AuthHandler().get_current_user),
1813
)
1814
1815
1578
-@incidents_db_operations_router.put("/case/customer-code", response_model=CaseOutResponse)
1816
+@incidents_db_operations_router.put(
1817
+ "/case/customer-code",
1818
+ response_model=CaseOutResponse,
1819
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1820
+)
1821
async def update_case_customer_code_endpoint(
1822
case_id: int,
1823
customer_code: str,
1851
)
1852
1853
1612
-@incidents_db_operations_router.delete("/case/{case_id}")
1854
+@incidents_db_operations_router.delete(
1855
+ "/case/{case_id}",
1856
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1857
+)
1858
async def delete_case_endpoint(
1859
case_id: int,
1860
current_user: User = Depends(AuthHandler().get_current_user),
1874
return {"message": "Case deleted successfully", "success": True}
1875
1876
1632
-@incidents_db_operations_router.get("/case/status/{status}", response_model=CaseOutResponse)
1877
+@incidents_db_operations_router.get(
1878
+ "/case/status/{status}",
1879
+ response_model=CaseOutResponse,
1880
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1881
+)
1882
async def list_cases_by_status_endpoint(
1883
status: AlertStatus,
1884
page: int = Query(1, ge=1),
1920
)
1921
1922
1674
-@incidents_db_operations_router.get("/case/assigned-to/{assigned_to}", response_model=CaseOutResponse)
1923
+@incidents_db_operations_router.get(
1924
+ "/case/assigned-to/{assigned_to}",
1925
+ response_model=CaseOutResponse,
1926
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1927
+)
1928
async def list_cases_by_assigned_to_endpoint(
1929
assigned_to: str,
1930
current_user: User = Depends(AuthHandler().get_current_user),
1947
return CaseOutResponse(cases=cases, success=True, message="Cases retrieved successfully")
1948
1949
1697
-@incidents_db_operations_router.get("/case/asset/{asset_name}", response_model=CaseOutResponse)
1950
+@incidents_db_operations_router.get(
1951
+ "/case/asset/{asset_name}",
1952
+ response_model=CaseOutResponse,
1953
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1954
+)
1955
async def list_cases_by_asset_name_endpoint(
1956
asset_name: str,
1957
current_user: User = Depends(AuthHandler().get_current_user),
1980
return CaseOutResponse(cases=cases, success=True, message="Cases retrieved successfully")
1981
1982
1726
-@incidents_db_operations_router.get("/case/customer/{customer_code}", response_model=CaseOutResponse)
1983
+@incidents_db_operations_router.get(
1984
+ "/case/customer/{customer_code}",
1985
+ response_model=CaseOutResponse,
1986
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
1987
+)
1988
async def list_cases_by_customer_code_endpoint(
1989
customer_code: str,
1990
current_user: User = Depends(customer_access_handler.require_customer_access()),
2000
return CaseOutResponse(cases=await list_cases_by_customer_code(customer_code, db), success=True, message="Cases retrieved successfully")
2001
2002
1742
-@incidents_db_operations_router.get("/case/data-store", response_model=ListCaseDataStoreResponse)
2003
+@incidents_db_operations_router.get(
2004
+ "/case/data-store",
2005
+ response_model=ListCaseDataStoreResponse,
2006
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2007
+)
2008
async def list_all_case_data_store_files_endpoint(db: AsyncSession = Depends(get_db)):
2009
logger.info("Listing all files in the data store")
2010
return ListCaseDataStoreResponse(case_data_store=await list_all_files(db), success=True, message="Files retrieved successfully")
2011
2012
1748
-@incidents_db_operations_router.get("/case/data-store/{case_id}", response_model=ListCaseDataStoreResponse)
2013
+@incidents_db_operations_router.get(
2014
+ "/case/data-store/{case_id}",
2015
+ response_model=ListCaseDataStoreResponse,
2016
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2017
+)
2018
async def list_case_data_store_files_endpoint(
2019
case_id: int,
2020
current_user: User = Depends(AuthHandler().get_current_user),
2037
)
2038
2039
1771
-@incidents_db_operations_router.get("/case/data-store/download/{case_id}/{file_name}")
2040
+@incidents_db_operations_router.get(
2041
+ "/case/data-store/download/{case_id}/{file_name}",
2042
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2043
+)
2044
async def download_case_data_store_file_endpoint(
2045
case_id: int,
2046
file_name: str,
2065
return StreamingResponse(output, media_type=file_content_type, headers={"Content-Disposition": f"attachment; filename={file_name}"})
2066
2067
1796
-@incidents_db_operations_router.post("/case/data-store/upload", response_model=CaseDataStoreResponse)
2068
+@incidents_db_operations_router.post(
2069
+ "/case/data-store/upload",
2070
+ response_model=CaseDataStoreResponse,
2071
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2072
+)
2073
async def upload_case_data_store_endpoint(
2074
case_id: int,
2075
file: UploadFile = File(...),
2096
)
2097
2098
1823
-@incidents_db_operations_router.delete("/case/data-store/{case_id}/{file_name}")
2099
+@incidents_db_operations_router.delete(
2100
+ "/case/data-store/{case_id}/{file_name}",
2101
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2102
+)
2103
async def delete_case_data_store_file_endpoint(
2104
case_id: int,
2105
file_name: str,
2120
return {"message": "File deleted successfully", "success": True}
2121
2122
1844
-@incidents_db_operations_router.get("/case/{case_id}", response_model=CaseOutResponse)
2123
+@incidents_db_operations_router.get(
2124
+ "/case/{case_id}",
2125
+ response_model=CaseOutResponse,
2126
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2127
+)
2128
async def get_case_by_id_endpoint(
2129
case_id: int,
2130
current_user: User = Depends(AuthHandler().get_current_user),
2143
return CaseOutResponse(cases=[case], success=True, message="Case retrieved successfully")
2144
2145
1863
-@incidents_db_operations_router.post("/case/notification", response_model=CaseNotificationResponse)
2146
+@incidents_db_operations_router.post(
2147
+ "/case/notification",
2148
+ response_model=CaseNotificationResponse,
2149
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2150
+)
2151
async def create_case_notification_endpoint(
2152
request: CaseNotificationCreate,
2153
current_user: User = Depends(AuthHandler().get_current_user),
2201
return CaseNotificationResponse(success=True, message="Case notification created successfully")
2202
2203
1917
-@incidents_db_operations_router.get("/case-report-template", response_model=CaseReportTemplateDataStoreListResponse)
2204
+@incidents_db_operations_router.get(
2205
+ "/case-report-template",
2206
+ response_model=CaseReportTemplateDataStoreListResponse,
2207
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2208
+)
2209
async def list_case_report_template_data_store_files_endpoint(db: AsyncSession = Depends(get_db)):
2210
logger.info("Listing all files in the data store")
2211
return CaseReportTemplateDataStoreListResponse(
2215
)
2216
2217
1927
-@incidents_db_operations_router.get("/case-report-template/do-default-template-exists")
2218
+@incidents_db_operations_router.get(
2219
+ "/case-report-template/do-default-template-exists",
2220
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2221
+)
2222
async def check_default_case_report_template_exists_endpoint(db: AsyncSession = Depends(get_db)):
2223
"""
2224
Endpoint to check if any of the default case report template files exist in the data store.
2237
return {"success": True, "message": "No default case report templates exist", "default_template_exists": False}
2238
2239
1946
-@incidents_db_operations_router.post("/case-report-template/default-template", response_model=CaseReportTemplateDataStoreListResponse)
2240
+@incidents_db_operations_router.post(
2241
+ "/case-report-template/default-template",
2242
+ response_model=CaseReportTemplateDataStoreListResponse,
2243
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2244
+)
2245
async def create_default_case_report_template_endpoint(db: AsyncSession = Depends(get_db)):
2246
"""
2247
Create a default case report template in the data store.
2260
)
2261
2262
1965
-@incidents_db_operations_router.get("/case-report-template/download/{file_name}")
2263
+@incidents_db_operations_router.get(
2264
+ "/case-report-template/download/{file_name}",
2265
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2266
+)
2267
async def download_case_report_template_endpoint(file_name: str, db: AsyncSession = Depends(get_db)) -> StreamingResponse:
2268
file_bytes, file_content_type = await download_report_template(file_name, db)
2269
logger.info(f"Streaming file {file_name}")
2273
return StreamingResponse(output, media_type=file_content_type, headers={"Content-Disposition": f"attachment; filename={file_name}"})
2274
2275
1975
-@incidents_db_operations_router.post("/case-report-template/upload", response_model=CaseReportTemplateDataStoreResponse)
2276
+@incidents_db_operations_router.post(
2277
+ "/case-report-template/upload",
2278
+ response_model=CaseReportTemplateDataStoreResponse,
2279
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2280
+)
2281
async def upload_case_report_template_endpoint(
2282
file: UploadFile = File(...),
2283
db: AsyncSession = Depends(get_db),
2298
)
2299
2300
1996
-@incidents_db_operations_router.delete("/case-report-template/{file_name}")
2301
+@incidents_db_operations_router.delete(
2302
+ "/case-report-template/{file_name}",
2303
+ dependencies=[Security(AuthHandler().require_any_scope("admin", "analyst", "customer_user"))],
2304
+)
2305
async def delete_case_report_template_endpoint(file_name: str, db: AsyncSession = Depends(get_db)):
2306
await delete_report_template(file_name, db)
2307
return {"message": "File deleted successfully", "success": True}