def validate(self) -> None:
exceptions: List[ValidationError] = []
owner_ids: Optional[List[int]] = self._properties.get("owners")
slug: Optional[str] = self._properties.get("slug")
# Validate/populate model exists
self._model = DashboardDAO.find_by_id(self._model_id)
if not self._model:
raise DashboardNotFoundError()
# Check ownership
try:
check_ownership(self._model)
except SupersetSecurityException:
raise DashboardForbiddenError()
# Validate slug uniqueness
if not DashboardDAO.validate_update_slug_uniqueness(
self._model_id, slug):
exceptions.append(DashboardSlugExistsValidationError())
# Validate/Populate owner
if owner_ids is None:
owner_ids = [owner.id for owner in self._model.owners]
try:
owners = populate_owners(self._actor, owner_ids)
self._properties["owners"] = owners
except ValidationError as ex:
exceptions.append(ex)
if exceptions:
exception = DashboardInvalidError()
exception.add_list(exceptions)
raise exception
def get_charts_for_dashboard(dashboard_id: int) -> List[Slice]:
query = (db.session.query(Dashboard).outerjoin(
Slice, Dashboard.slices).outerjoin(
Slice.table).filter(Dashboard.id == dashboard_id).options(
contains_eager(Dashboard.slices)))
dashboard = query.one_or_none()
if not dashboard:
raise DashboardNotFoundError()
return dashboard.slices
def validate(self) -> None:
# Validate/populate model exists
self._model = DashboardDAO.find_by_id(self._model_id)
if not self._model:
raise DashboardNotFoundError()
# Check ownership
try:
check_ownership(self._model)
except SupersetSecurityException:
raise DashboardForbiddenError()
def validate(self) -> None:
# Validate/populate model exists
self._models = DashboardDAO.find_by_ids(self._model_ids)
if not self._models or len(self._models) != len(self._model_ids):
raise DashboardNotFoundError()
# Check ownership
for model in self._models:
try:
check_ownership(model)
except SupersetSecurityException:
raise DashboardForbiddenError()
def get_by_id_or_slug(id_or_slug: str) -> Dashboard:
query = (db.session.query(Dashboard).filter(
id_or_slug_filter(id_or_slug)).outerjoin(
Slice, Dashboard.slices).outerjoin(Slice.table).outerjoin(
Dashboard.owners).outerjoin(Dashboard.roles))
# Apply dashboard base filters
query = DashboardFilter("id",
SQLAInterface(Dashboard,
db.session)).apply(query, None)
dashboard = query.one_or_none()
if not dashboard:
raise DashboardNotFoundError()
return dashboard
def get_charts_for_dashboard(id_or_slug: str) -> List[Slice]:
query = (db.session.query(Dashboard).outerjoin(
Slice, Dashboard.slices).outerjoin(Slice.table).filter(
id_or_slug_filter(id_or_slug)).options(
contains_eager(Dashboard.slices)))
# Apply dashboard base filters
query = DashboardFilter("id",
SQLAInterface(Dashboard,
db.session)).apply(query, None)
dashboard = query.one_or_none()
if not dashboard:
raise DashboardNotFoundError()
return dashboard.slices
def get_datasets_for_dashboard(id_or_slug: str) -> List[Any]:
query = (db.session.query(Dashboard).filter(
id_or_slug_filter(id_or_slug)).outerjoin(
Slice, Dashboard.slices).outerjoin(Slice.table))
# Apply dashboard base filters
query = DashboardFilter("id",
SQLAInterface(Dashboard,
db.session)).apply(query, None)
dashboard = query.one_or_none()
if not dashboard:
raise DashboardNotFoundError()
datasource_slices = core.indexed(dashboard.slices, "datasource")
data = [
datasource.data_for_slices(slices)
for datasource, slices in datasource_slices.items() if datasource
]
return data
def validate(self) -> None:
# Validate/populate model exists
self._model = DashboardDAO.find_by_id(self._model_id)
if not self._model:
raise DashboardNotFoundError()
# Check there are no associated ReportSchedules
reports = ReportScheduleDAO.find_by_dashboard_id(self._model_id)
if reports:
report_names = [report.name for report in reports]
raise DashboardDeleteFailedReportsExistError(
_("There are associated alerts or reports: %s" %
",".join(report_names)))
# Check ownership
try:
check_ownership(self._model)
except SupersetSecurityException as ex:
raise DashboardForbiddenError() from ex
def validate(self) -> None:
# Validate/populate model exists
self._models = DashboardDAO.find_by_ids(self._model_ids)
if not self._models or len(self._models) != len(self._model_ids):
raise DashboardNotFoundError()
# Check there are no associated ReportSchedules
reports = ReportScheduleDAO.find_by_dashboard_ids(self._model_ids)
if reports:
report_names = [report.name for report in reports]
raise DashboardBulkDeleteFailedReportsExistError(
_("There are associated alerts or reports: %s" % ",".join(report_names))
)
# Check ownership
for model in self._models:
try:
security_manager.raise_for_ownership(model)
except SupersetSecurityException as ex:
raise DashboardForbiddenError() from ex
def get_by_id_or_slug(id_or_slug: str) -> Dashboard:
dashboard = Dashboard.get(id_or_slug)
if not dashboard:
raise DashboardNotFoundError()
security_manager.raise_for_dashboard_access(dashboard)
return dashboard
def _validate_filterset_dashboard_exists(self) -> None:
self._dashboard = DashboardDAO.get_by_id_or_slug(
str(self._dashboard_id))
if not self._dashboard:
raise DashboardNotFoundError()
def validate(self) -> None:
self._models = DashboardDAO.find_by_ids(self.dashboard_ids)
if len(self._models) != len(self.dashboard_ids):
raise DashboardNotFoundError()