async def delete_enum_by_id_by_super_admin(
enum_id: Optional[EnumId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> Enum:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(enum_id):
raise_400('Enumeration id is required.')
enum_service = get_enum_service(principal_service)
def action() -> Enum:
# noinspection PyTypeChecker
an_enum: Enum = enum_service.delete(enum_id)
if an_enum is None:
raise_404()
enum_item_service = get_enum_item_service(enum_service)
enum_items = enum_item_service.find_by_enum_id(an_enum.enumId)
if enum_items is None:
an_enum.items = []
else:
an_enum.items = enum_items
enum_item_service.delete_by_enum_id(an_enum.enumId)
return an_enum
return trans(enum_service, action)
async def delete_user_by_id_by_super_admin(
user_id: Optional[UserId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> User:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(user_id):
raise_400('User id is required.')
user_service = get_user_service(principal_service)
def action() -> User:
# noinspection PyTypeChecker
user: User = user_service.delete(user_id)
if user is None:
raise_404()
user_group_ids = user.groupIds
if user_group_ids is not None and len(user_group_ids) != 0:
user_group_ids = ArrayHelper(user_group_ids).filter(
lambda x: is_not_blank(x)).to_list()
remove_user_from_groups(user_service, user.userId, user_group_ids,
user.tenantId)
return user
return trans(user_service, action)
async def delete_dashboard_by_id_by_super_admin(
dashboard_id: Optional[DashboardId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> Dashboard:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(dashboard_id):
raise_400('Report id is required.')
dashboard_service = get_dashboard_service(principal_service)
def action() -> Dashboard:
# noinspection PyTypeChecker
dashboard: Dashboard = dashboard_service.delete(dashboard_id)
if dashboard is None:
raise_404()
return dashboard
return trans(dashboard_service, action)
async def delete_report_by_id_by_super_admin(
report_id: Optional[ReportId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> Report:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(report_id):
raise_400('Report id is required.')
report_service = get_report_service(principal_service)
def action() -> Report:
# noinspection PyTypeChecker
report: Report = report_service.delete(report_id)
if report is None:
raise_404()
return report
return trans(report_service, action)
async def delete_topic_by_id_by_super_admin(
topic_id: Optional[TopicId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> Topic:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(topic_id):
raise_400('Topic id is required.')
topic_service = get_topic_service(principal_service)
def action() -> Topic:
# noinspection PyTypeChecker
topic: Topic = topic_service.delete(topic_id)
if topic is None:
raise_404()
post_delete_topic(topic.topicId, topic_service)
return topic
return trans(topic_service, action)
async def delete_pipeline_by_id_by_super_admin(
pipeline_id: Optional[PipelineId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> Pipeline:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(pipeline_id):
raise_400('Topic id is required.')
pipeline_service = get_pipeline_service(principal_service)
def action() -> Pipeline:
# noinspection PyTypeChecker
pipeline: Pipeline = pipeline_service.delete(pipeline_id)
if pipeline is None:
raise_404()
post_delete_pipeline(pipeline.pipelineId, pipeline_service)
return pipeline
return trans(pipeline_service, action)
async def delete_external_writer_by_id(
writer_id: Optional[ExternalWriterId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> ExternalWriter:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(writer_id):
raise_400('External writer id is required.')
external_writer_service = get_external_writer_service(principal_service)
def action() -> ExternalWriter:
# noinspection PyTypeChecker
external_writer: ExternalWriter = external_writer_service.delete(
writer_id)
if external_writer is None:
raise_404()
return external_writer
return trans(external_writer_service, action)
async def delete_data_source_by_id_by_super_admin(
data_source_id: Optional[DataSourceId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> DataSource:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(data_source_id):
raise_400('Data source id is required.')
data_source_service = get_data_source_service(principal_service)
def action() -> DataSource:
# noinspection PyTypeChecker
data_source: DataSource = data_source_service.delete(data_source_id)
if data_source is None:
raise_404()
CacheService.data_source().remove(data_source_id)
return data_source
return trans(data_source_service, action)
async def delete_tenant_by_id_by_super_admin(
tenant_id: Optional[TenantId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> Tenant:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(tenant_id):
raise_400('Tenant id is required.')
tenant_service = get_tenant_service(principal_service)
def action() -> Tenant:
# noinspection PyTypeChecker
tenant: Tenant = tenant_service.delete(tenant_id)
if tenant is None:
raise_404()
CacheService.tenant().remove(tenant_id)
return tenant
return trans(tenant_service, action)
async def delete_last_snapshot_by_id(
user_id: Optional[UserId],
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> LastSnapshot:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(user_id):
raise_400('User id is required.')
last_snapshot_service = get_last_snapshot_service(principal_service)
def action() -> LastSnapshot:
# noinspection PyTypeChecker
last_snapshot: LastSnapshot = last_snapshot_service.delete_by_id(
user_id)
if last_snapshot is None:
raise_404()
return last_snapshot
return trans(last_snapshot_service, action)
async def delete_connected_space_graphic_by_id_by_super_admin(
connect_id: Optional[ConnectedSpaceId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> ConnectedSpaceGraphic:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(connect_id):
raise_400('Connected space id is required.')
connected_space_graphic_service = get_connected_space_graphic_service(
principal_service)
def action() -> ConnectedSpaceGraphic:
# noinspection PyTypeChecker
connected_space_graphic: ConnectedSpaceGraphic = connected_space_graphic_service.delete(
connect_id)
if connected_space_graphic is None:
raise_404()
return connected_space_graphic
return trans(connected_space_graphic_service, action)
async def delete_connected_space_by_id_by_super_admin(
connect_id: Optional[ConnectedSpaceId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> ConnectedSpaceWithSubjects:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(connect_id):
raise_400('Connected space id is required.')
connected_space_service = get_connected_space_service(principal_service)
# noinspection DuplicatedCode
def action() -> ConnectedSpaceWithSubjects:
# noinspection PyTypeChecker
existing_connected_space: Optional[
ConnectedSpace] = connected_space_service.find_by_id(connect_id)
if existing_connected_space is None:
raise_404()
# noinspection PyTypeChecker
connected_space: ConnectedSpace = connected_space_service.delete(
connect_id)
subject_service: SubjectService = get_subject_service(
connected_space_service)
subjects: List[Subject] = subject_service.delete_by_connect_id(
connect_id)
report_service: ReportService = get_report_service(
connected_space_service)
reports: List[Report] = report_service.delete_by_connect_id(connect_id)
report_map: Dict[SubjectId, List[Report]] = ArrayHelper(
reports).group_by(lambda x: x.subjectId)
connected_space_with_subjects = ConnectedSpaceWithSubjects(
**connected_space.dict())
connected_space_with_subjects.subjects = ArrayHelper(subjects) \
.map(lambda x: to_subject_with_reports(x, report_map.get(x.subjectId))).to_list()
return connected_space_with_subjects
return trans(connected_space_service, action)
async def delete_subject_by_id_by_super_admin(
subject_id: Optional[SubjectId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> SubjectWithReports:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(subject_id):
raise_400('Subject id is required.')
subject_service = get_subject_service(principal_service)
def action() -> SubjectWithReports:
# noinspection PyTypeChecker
subject: Subject = subject_service.delete(subject_id)
if subject is None:
raise_404()
report_service: ReportService = get_report_service(subject_service)
reports: List[Report] = report_service.delete_by_subject_id(subject_id)
return SubjectWithReports(**subject.dict(), reports=reports)
return trans(subject_service, action)
async def delete_scheduler(
scheduler_id: Optional[TopicSnapshotSchedulerId],
principal_service: PrincipalService = Depends(get_admin_principal)
) -> None:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(scheduler_id):
raise_400('Scheduler id is required.')
scheduler_service = get_topic_snapshot_scheduler_service(principal_service)
# noinspection DuplicatedCode
def action() -> None:
# noinspection PyTypeChecker
existing_scheduler: Optional[
TopicSnapshotScheduler] = scheduler_service.find_by_id(
scheduler_id)
if existing_scheduler is None:
raise_404()
scheduler_service.delete(scheduler_id)
trans(scheduler_service, action)
async def delete_space_by_id_by_super_admin(
space_id: Optional[SpaceId] = None,
principal_service: PrincipalService = Depends(get_super_admin_principal)
) -> Space:
if not ask_tuple_delete_enabled():
raise_404('Not Found')
if is_blank(space_id):
raise_400('Space id is required.')
space_service = get_space_service(principal_service)
def action() -> Space:
# noinspection PyTypeChecker
space: Space = space_service.delete(space_id)
if space is None:
raise_404()
user_group_ids = space.groupIds
if user_group_ids is not None and len(user_group_ids) != 0:
user_group_ids = ArrayHelper(user_group_ids).filter(lambda x: is_not_blank(x)).to_list()
remove_space_from_groups(space_service, space.spaceId, user_group_ids, space.tenantId)
return space
return trans(space_service, action)
