@angular/material/dialog#MatDialog TypeScript Examples

constructor(
    private route: ActivatedRoute,
    private burp: ConfigService,
    private _snackBar: MatSnackBar,
    public dialog: MatDialog,
    private hostsService: HostsService,
    private stepsService: StepsService,
    private router: Router,
    private missionsService: MissionsService,
    private uploadServices: UploadsService,
    private fb: FormBuilder
  ) {
    this.missionId = this.router.url.split('/').pop();
  }

constructor(
    private authService: AuthService,
    private projectApiService: ProjectApiService,
    public dialog: MatDialog,
    public dialogRef: MatDialogRef<BomGroupedLicenseModulesComponent>,
    private messageService: BomLicenseExceptionOperationMessageService,
  ) {
    messageService
      .get()
      .pipe(untilDestroyed(this))
      .subscribe(() => {
        this.dialogRef.close();
      });
  }

constructor(
		@Inject(DOCUMENT) private document: Document,
		private metaService: Meta,
		private restService: RestService,
		private route: ActivatedRoute,
		private router: Router,
		private cdr: ChangeDetectorRef,
		private dialog: MatDialog,
		private appService: AppService,
		private emoteListService: EmoteListService,
		private dataService: DataService,
		public themingService: ThemingService,
		public clientService: ClientService
	) { }

constructor(
    public dialogRef: MatDialogRef<HeroSelectDialogComponent>,
    @Inject(MAT_DIALOG_DATA) public data: HeroSelectDialogData,
    private characterService: CharacterService,
    private localStorageService: LocalStorageService,
    private dialog: MatDialog
  ) {
    console.log(data);
    if (this.data.party) {
      this.selectedChars = this.data.party.tiles.reduce((acc, tile) => {
        if (tile.character) {
          acc.push(tile.character);
        }
        return acc;
      }, []);
    }

    // Filter those out by default
    if (this.onlyUniques === null) {
      this.onlyUniques = true;
    }
    // Enable by default
    if (this.separateByElement === null) {
      this.separateByElement = true;
    }
    this.toggleRares();
    this.filterField.valueChanges.subscribe(() => {
      this.updateFilters();
    });
  }

constructor(
    private readonly changeDetectorRef: ChangeDetectorRef,
    private readonly dataStore: DataStore,
    private readonly dataAnalyzer: DataAnalyzer,
    private readonly dialog: MatDialog,
    private readonly zone: NgZone,
    private readonly home: HomeComponent,
  ) {
    this.alertActionCtx = {
      showItemInItems: (itemID: ItemID) => {
        this.home.showInItems(itemID)
      },
      showItemInQueue: (itemID: ItemID) => {
        this.home.showInQueue(itemID)
      },
      editItem: (itemID: ItemID) => {
        const item = this.dataStore.getItem(itemID)
        if (item === undefined) return
        const dialogRef = this.dialog.open(ItemDetailsComponent, {
          width: ItemDetailsComponent.DIALOG_WIDTH,
          data: {item},
          hasBackdrop: true,
          disableClose: false,
          autoFocus: false,
        })
      },
      dataStore: this.dataStore,
    }
  }

public constructor(
    private _dialog: MatDialog,
    private _addonService: AddonService,
    private _translateService: TranslateService,
    private _ngZone: NgZone
  ) {
    this._addonService.addonInstalled$
      .pipe(
        takeUntil(this._destroy$),
        filter(
          (evt) =>
            evt.addon.externalId === this.listItem.addon?.externalId &&
            evt.addon.providerName === this.listItem.addon?.providerName
        )
      )
      .subscribe((evt) => {
        this._ngZone.run(() => {
          this.installState = evt.installState;
          this.installProgress = evt.progress;

          if (evt.installState !== AddonInstallState.Complete) {
            this.showStatusText = false;
          } else {
            this.showStatusText = !AddonUtils.needsUpdate(evt.addon) || (this.listItem?.addon?.isIgnored ?? true);
          }
          this.statusText = this.getStatusText(evt.addon);
        });
      });
  }

constructor(
    private authService: AuthService,
    private oauthService: OAuthService,
    private formBuilder: FormBuilder,
    private snackBar: MatSnackBar,
    private dialog: MatDialog,
    private route: ActivatedRoute,
    private router: Router
  ) {}

constructor(private dialog: MatDialog, private messageService: MessageService, private authService: AuthService,
    private dlcService: DLCService, private offerService: OfferService, private addressService: AddressService,
    private contactService: ContactService) {
      this.dlcService.initialized.subscribe(v => {
        if (v) this.checkInitialized()
      })
      this.offerService.initialized.subscribe(v => {
        if (v) this.checkInitialized()
      })
    }

constructor(
        private authService: AuthenticationService,
        private appState: ApplicationStateService,
        private router: Router,
        private fb: FormBuilder,
        private log: Logger,
        public dialog: MatDialog,
        public snackBar: MatSnackBar,
        private globalService: GlobalService,
        private apiService: ApiService) {

        this.onGenerate();
    }

constructor(private route: ActivatedRoute, 
                private router: Router, 
                private restAPIConnectorService: RestApiConnectorService,
                private dialog: MatDialog,
                private editorService: EditorService) {
                    
        this.onEditStopSubscription = this.editorService.onEditingStopped.subscribe({
            next: () => { this.loadHistory(); }
        })
    }

/**
     * get access to parent object's fields
     *
     * @param schemaChange  signal a change
     * @param name          the current property name (key)
     * @param schema        the current schema
     * @param parent        the parent's schema (required in order to change the order)
     * @param dialog        dialog service
     */
    constructor(
        private schemaChange: EventEmitter<void>, private name: string, private schema: Schema, private parent: Schema,
        private dialog: MatDialog, private component: ComponentType<any>) {
    }

constructor(
    private dataService: DataService,
    private route: ActivatedRoute,
    public dialog: MatDialog,
    private location: Location,
    fb: FormBuilder
  ) {
    this.sort = new MatSort();
    this.sectorFilters.forEach(
      (sector: { sector: string; activated: boolean }) => {
        if (sector.activated) {
          this.checkboxes.push(sector.sector);
        }
      }
    );
  }

constructor(
        private authService: AuthenticationService,
        private appState: ApplicationStateService,
        private router: Router,
        private fb: FormBuilder,
        private log: Logger,
        public dialog: MatDialog,
        public snackBar: MatSnackBar,
        private globalService: GlobalService,
        private apiService: ApiService) {

        this.onGenerate();
    }

// Used for upload csv option
  // @ViewChild('fileInput')
  // fileInput;

  // file: File | null = null;

  // onClickFileInputButton(): void {
  //   this.fileInput.nativeElement.click();
  // }
  
  // onChangeFileInput(): void {
  //   const files: { [key: string]: File } = this.fileInput.nativeElement.files;
  //   this.file = files[0];
  // }
  
  constructor(
    private _formBuilder: FormBuilder,
    private _configService: ConfigService,
    private _uploadAssetService: UploadAssetService,
    private _assetService: AssetService,
    private _vidSelect: MatDialogRef<VideoSelectComponent>,
    private dialog: MatDialog,
    ) {}

constructor(private dialog: MatDialog,
              private tutorialService: BdcWalkService) { }

constructor(
    private http: HttpClient,
    private router: Router,
    private dialog: MatDialog,
    private themeService: ThemeService
  ) {}

constructor(public dialog: MatDialog, private lcuConnectionService: LCUConnectionService, private version: VersionService, private championData: ChampionService) {
  }

constructor(
    private spotifyService: SpotifyService,
    private notificationService: NotificationService,
    private dialog: MatDialog) {
  }

constructor(
    public dialogRef: MatDialogRef<BomManualLicenseDetailsDialogComponent>,
    private dialog: MatDialog,
    public bomManualLicenseApiService: BomManualLicenseApiService,
    public licenseApiService: LicenseApiService,
  ) {
    super();
  }

constructor(private dialog: MatDialog) {
    this.init();
  }

constructor(
		public themingService: ThemingService,
		private clientService: ClientService,
		private router: Router,
		private restService: RestService,
		private dataService: DataService,
		private dialog: MatDialog
	) { }

constructor(
    private dialog: MatDialog,
    private languageService: LanguageService,
    private localStorageService: LocalStorageService,
    private characterService: CharacterService,
    private route: ActivatedRoute,
    private changeDetectorRef: ChangeDetectorRef,
  ) { }

constructor(
    private readonly dataStore: DataStore,
    private readonly dataAnalyzer: DataAnalyzer,
    private readonly dialog: MatDialog,
    private readonly snackBar: MatSnackBar,
  ) {
  }

constructor(
    private apiService: ApiService,
    public dialog: MatDialog,
  ) {
  }

constructor(
    public tabsSVC: TabsNavService,
    private backendSVC: BackendService,
    public dialog: MatDialog,
    private ngZone: NgZone,
    public usrSVC: UserLoginService,
    private fileBrowserSVC: FileBrowserService
  ) { }

public constructor(
    private _addonService: AddonService,
    private _addonProviderService: AddonProviderFactory,
    private _analyticsService: AnalyticsService,
    private _cdRef: ChangeDetectorRef,
    private _dialog: MatDialog,
    private _fileService: FileService,
    private _preferenceStore: PreferenceStorageService,
    private _snackbarService: SnackbarService,
    private _translateService: TranslateService,
    private _warcraftInstallationService: WarcraftInstallationService,
    private _wowupAddonService: WowUpAddonService,
    private _zoomService: ZoomService,
    private _wowUpProtocolService: WowUpProtocolService,
    public electronService: ElectronService,
    public overlayContainer: OverlayContainer,
    public sessionService: SessionService,
    public wowUpService: WowUpService
  ) {
    this._warcraftInstallationService.wowInstallations$
      .pipe(
        first((installations) => installations.length > 0),
        switchMap(() => from(this.initializeAutoUpdate()))
      )
      .subscribe();

    this.electronService.appUpdate$.subscribe((evt) => {
      if (evt.state === AppUpdateState.Error) {
        if (evt.error.indexOf("dev-app-update.yml") === -1) {
          this._snackbarService.showErrorSnackbar("APP.WOWUP_UPDATE.UPDATE_ERROR");
        }
      } else if (evt.state === AppUpdateState.Downloaded) {
        // Force the user to update when one is ready
        const dialogRef = this._dialog.open(AlertDialogComponent, {
          minWidth: 250,
          disableClose: true,
          data: {
            title: this._translateService.instant("APP.WOWUP_UPDATE.INSTALL_TITLE"),
            message: this._translateService.instant("APP.WOWUP_UPDATE.SNACKBAR_TEXT"),
            positiveButton: "APP.WOWUP_UPDATE.DOWNLOADED_TOOLTIP",
            positiveButtonColor: "primary",
            positiveButtonStyle: "raised",
          },
        });

        dialogRef
          .afterClosed()
          .pipe(first())
          .subscribe(() => {
            this.wowUpService.installUpdate();
          });
      }
    });

    this._wowUpProtocolService.initialize();
  }