code: def validate(self) -> None:
      exceptions: list[ValidationError] = []
      owner_ids: Optional[list[int]] = self._properties.get("owners")
      report_type = self._properties.get(
          "type", ReportScheduleType.ALERT
      )
  
      name = self._properties.get("name", "")
      self._model = ReportScheduleDAO.find_by_id(self._model_id)
  
      # Does the report exist?
      if not self._model:
          raise ReportScheduleNotFoundError()
  
      # Change the state to not triggered when the user deactivates
      # A report that is currently in a working state. This prevents
      # an alert/report from being kept in a working state if activated back
      if (
          self._model.last_state == ReportState.WORKING
          and "active" in self._properties
          and not self._properties["active"]
      ):
          self._properties["last_state"] = ReportState.NOOP
  
      # validate relation by report type
      if not report_type:
          report_type = self._model.type
  
      # Validate name type uniqueness
      if not ReportScheduleDAO.validate_update_uniqueness(
          name, report_type, expect_id=self._model_id
      ):
          exceptions.append(
              ReportScheduleNameUniquenessValidationError(
                  report_type=report_type, name=name
              )
          )
  
      if report_type == ReportScheduleType.ALERT:
          database_id = self._properties.get("database")
          # If database_id was sent let's validate it exists
          if database_id:
              database = DatabaseDAO.find_by_id(database_id)
              if not database:
                  exceptions.append(DatabaseNotFoundValidationError())
              self._properties["database"] = database
  
      # Validate chart or dashboard relations
      self.validate_chart_dashboard(exceptions, update=True)
  
      if "validator_config_json" in self._properties:
          self._properties["validator_config_json"] = json.dumps(
              self._properties["validator_config_json"]
          )
  
      # Check ownership
      try:
          security_manager.raise_for_ownership(self._model)
      except SupersetSecurityException as ex:
          raise ReportScheduleForbiddenError() from ex
  
      # Validate/Populate owner
      if owner_ids is None:
          owner_ids = [owner.id for owner in self._model.owners]
      try:
          owners = self.populate_owners(owner_ids)
          self._properties["owners"] = owners
      except ValidationError as ex:
          exceptions.append(ex)
      if exceptions:
          raise ReportScheduleInvalidError(exceptions=exceptions)
  
file_path: superset/superset/commands/report/update.py
imports: import json
  import logging
  from typing import Any, Optional
  from flask_appbuilder.models.sqla import Model
  from marshmallow import ValidationError
  from superset import security_manager
  from superset.commands.base import UpdateMixin
  from superset.commands.report.base import BaseReportScheduleCommand
  from superset.commands.report.exceptions import DatabaseNotFoundValidationError, ReportScheduleForbiddenError, ReportScheduleInvalidError, ReportScheduleNameUniquenessValidationError, ReportScheduleNotFoundError, ReportScheduleUpdateFailedError
  from superset.daos.database import DatabaseDAO
  from superset.daos.exceptions import DAOUpdateFailedError
  from superset.daos.report import ReportScheduleDAO
  from superset.exceptions import SupersetSecurityException
  from superset.reports.models import ReportSchedule, ReportScheduleType, ReportState
label_desc: Use image node_id 3 for calling the UpdateReportScheduleCommand obj's underlying member method code with example usage: obj.validate() without return types