TypeScript TranslateService.get方法代码示例

 async create(opts?: AlertOptions, toTranslate = ['message', 'title', 'subTitle']): Promise<Alert> {
   if (opts) {
     for (const key of toTranslate) {
       if (opts[key]) {
         opts[key] = await this.translate.get(opts[key]).toPromise();
       }
     }
     if (opts.buttons) {
       for (const button of opts.buttons as AlertButton[]) {
         if (button.text) {
           button.text = await this.translate.get(button.text).toPromise();
         }
       }
     }
     if (opts.inputs) {
       for (const input of opts.inputs) {
         if (input.placeholder) {
           input.placeholder = await this.translate.get(input.placeholder).toPromise();
         }
         if (input.label) {
           input.label = await this.translate.get(input.label).toPromise();
         }
       }
     }
   }
   return this.alertCtrl.create(opts);
 }

		this.httpManagerService.post('/json/user/lang', {'uid': this.getUid(), 'lang': key}).subscribe(res => {
			forkJoin(
				this.translateService.get(res.alert.content),
				this.translateService.get('FORM_BUTTON_CLOSE'))
			.subscribe(([msg, action]) => {
				let snackBarRef = this.snackBar.open(msg, action, {
					'duration': 5000
				});
			});
		});

 validateUserPassword(newPassword, confirmPassword): boolean {
     let passwordEmptyFault = newPassword === '' && confirmPassword === '';
     let arePasswordsSame = newPassword === confirmPassword;
     if (passwordEmptyFault) {
         this.translate.get('app.profile.message.error.emptyPassword').subscribe(message => {
             this.util.presentModal(message);
         });
     } else if (!arePasswordsSame) {
         this.translate.get('app.profile.message.error.mismatchPassword').subscribe(message => {
             this.util.presentModal(message);
         });
     }
     return !passwordEmptyFault && arePasswordsSame;
 }

  /*
   * Displays an info message
   */
  toastInfo(reason?: string)
  {
    let message: string;
    let key: string;

    switch(reason)
    {
      case 'jobRegistered':
        key = 'TOASTR.INFO.JOB';
        break;
      case 'noResult':
        key = 'TOASTR.INFO.NORESULT';
        break;
      case'restartNeeded':
        key = 'TOASTR.INFO.RESTART';
        break;
      default:
        key = 'TOASTR.INFO.DEFAULT';
        break;
    }

    this.translateService.get(key).subscribe(
      value => {
        message = value;
      });

    this.toastr.info(message)
  }

 /*
  * Displays an error at setup
  */
 toastSetupError(code :number)
 {
   let key: string;
   switch(code)
   {
     case 1:
       key = 'TOASTR.SETUP.SQLERROR';
       break;
     case 2:
       key = 'TOASTR.SETUP.PATHERROR';
       break;
     case 4:
       key = 'TOASTR.SETUP.USERERROR';
       break;
     case 5:
       key = 'TOASTR.SETUP.USERERROR';
       break;
     case 6:
       key = 'TOASTR.SETUP.SETERROR';
       break;
     default:
       key = 'TOASTR.ERROR.DEFAULT';
   }
   let message: string
   this.translateService.get(key).subscribe(
     value => {
       message = value;
     });
   this.toastr.error(message);
 }

 ngOnInit() {
     this.funcImagePath = this.webAppSettingDataService.getImagePathMakeFunc();
     this.browserInfoList = [
         {
             downloadLink: 'https://www.google.com/chrome',
             name: 'chrome',
             displayName: 'Google Chrome'
         }, {
             downloadLink: 'https://www.mozilla.org/en/firefox/new',
             name: 'firefox',
             displayName: 'Mozilla Firefox'
         }, {
             downloadLink: 'https://support.apple.com/en-us/HT204416',
             name: 'safari',
             displayName: 'Apple Safari'
         }, {
             downloadLink: 'https://www.microsoft.com/en-us/windows/microsoft-edge',
             name: 'edge',
             displayName: 'Microsoft Edge'
         }, {
             downloadLink: 'https://whale.naver.com/en/',
             name: 'whale',
             displayName: 'Naver Whale'
         }
     ];
     this.i18nText$ = this.translateService.get('SUPPORT.INSTALL_GUIDE');
 }

  /*
   * Displays a warning message
   */
  toastWarning(reason?: string)
  {
    let key: string;
    switch(reason)
    {
      case 'accessDenied':
        key = 'TOASTR.WARNING.ACCESS';
        break;
      case 'noResult':
        key = 'TOASTR.WARNING.TIMEOUT';
        break;
      case 'timeout':
        key = 'TOASTR.WARNING.TIMEOUT';
        break;
      default:
        key = 'TOASTR.WARNING.DEFAULT';
        break;
    }

    let message: string;
    this.translateService.get(key).subscribe(
      value => {
        message = value;
      });

    this.toastr.warning(message)
  }

 setTimeout(() => {
   translate.get('TEST').subscribe((res2: string) => {
     expect(res2).toEqual('TEST'); // because the loader is "pristine" as if it was never called
     expect(http.expectOne).toHaveBeenCalledTimes(1);
     done();
   });
 }, 10);

  it('should be able to reset a lang', (done: Function) => {
    translate.use('en');
    spyOn(http, 'expectOne').and.callThrough();

    // this will request the translation from the backend because we use a static files loader for TranslateService
    translate.get('TEST').subscribe((res: string) => {
      expect(res).toEqual('This is a test');
      expect(http.expectOne).toHaveBeenCalledTimes(1);

      // reset the lang as if it was never initiated
      translate.resetLang('en');

      expect(translate.instant('TEST')).toEqual('TEST');

      // use set timeout because no request is really made and we need to trigger zone to resolve the observable
      setTimeout(() => {
        translate.get('TEST').subscribe((res2: string) => {
          expect(res2).toEqual('TEST'); // because the loader is "pristine" as if it was never called
          expect(http.expectOne).toHaveBeenCalledTimes(1);
          done();
        });
      }, 10);
    });

    // mock response after the xhr request, otherwise it will be undefined
    http.expectOne('/assets/i18n/en.json').flush({"TEST": "This is a test"});
  });

	public handleError(raw: Response | any) {
		console.error(raw);
		// If server sends 401 'Unauthorized'
		if(_.has(raw, 'status') && raw.status == 401 && raw._body == 'Unauthorized') {
			// Delete token in local storage and redirect
			window.localStorage.removeItem('currentUser');
			this.router.navigate(['/login']);
			
			return Observable.throw(raw);
		}
		
		var error = raw.json();
		
		// Show alert component if alert object is part of the server response
		var self = this;
		if(_.has(error, 'alert')) {
			// First clear old alerts
			self.alert.clear();
			
			// Push new alert
			this.translate.get(error.alert.content, error.alert.vars).subscribe(str => {
				self.alert.alert(error.alert.type, str);
			});
		}
		
		return Observable.throw(error);
	}