src/environments/environment#ENVIRONMENT TypeScript Examples

public addListeners(): void {
        if (!environment.production) {
            this.walletAddress.next('0x3a13D9b322F391a1AFab36a1d242C24F3250bA48');
            return;
        }

        appsSdk.addListeners({
            onSafeInfo: ((info: SafeInfo) => {

                this.isMainNet.next(info.network.toLowerCase() === 'mainnet');
                this.walletAddress.next(info.safeAddress);
            })
        });
    }

STAKING_CONTRACTS: RoundContract[] = [
  {
    address: ENVIRONMENT.staking.roundOneContractAddress,
    abi: STAKING_CONTRACT_ABI_ROUND_ONE
  },
  {
    address: ENVIRONMENT.staking.roundTwoContractAddress,
    abi: STAKING_CONTRACT_ABI_ROUND_TWO,
    active: true
  }
]

/**
   * 检测邮箱是否可用
   * @param email 邮箱
   */
  checkEmail(email: string): Observable<Result<boolean>> {
    return this.http.get<Result<boolean>>(environment.indexCtx + '/checkemail', {
      params: { email },
      context: new HttpContext().set(HTTP_CACHE_TOKEN, 5000)
    });
  }

gitHubLogin(code: string) {
        return this.http.post<any>(`${environment.apiUrl}/auth/social/github/login/`, { code: code })
            .pipe(map(({token, user}) => {
                user.token = token
                // store user details and jwt token in local storage to keep user logged in between page refreshes
                localStorage.setItem('currentUser', JSON.stringify(user));
                this.currentUserSubject.next(user);
                return user;
            }));
    }

getVideoFromApi(artist: string, trackName: string): Observable<any> {
        const key = environment.youtube_api_key;
        return this.http
            .get<any>(
                `https://www.googleapis.com/youtube/v3/search?part=snippet&videoCategoryId=10&maxResults=1&q=${artist} - ${trackName}&type=video&key=${key}`
            )
            .pipe(
                map((item) => {
                    const videoId = item.items[0].id.videoId;
                    return videoId;
                })
            );
    }

public getDashboardsInfo() {
    const url = environment.grafanaPrefix + '/api/search';

    return this.http.get<GrafanaDashboard[]>(url).pipe(
      catchError(error => this.handleError(error, false)),
      map((resp: GrafanaDashboard[]) => {
        return resp;
      }),
    );
  }

init() {
    this.content = new ContentManager();
    this.runner = new ScriptRunnerImpl(this.http, this.content, this.locale);
    this.runner.timeout = environment.chatRunnerTimeout;
    this.runner.debug = false;
    this.runner.fixme = () => {
      this.restart();
    };
  }

getCountryFromIp(): Observable<string> {
    const url = 'https://ipfind.co/me';
    const data = {
      params: {
        auth: environment.IP_FIND_KEY,
      },
    };

    return this.httpClient.get(url, data).pipe(
      map((response: any) => response.country),
      catchError((err) => of(null))
    );
  }

@HostListener('document:keyup', ['$event'])
  handleKeyboardEvent(event: KeyboardEvent) {
    const KeyMap = ['KeyR', 'KeyL', 'KeyU', 'KeyM', 'KeyC'];
    if (KeyMap.includes(event.code)) {
      const index = KeyMap.findIndex(e => e === event.code);
      if (this.compactDropDownMenu) {
        const name = environment.colors[index].name;
        if (name !== this.ntype.name) {
          this.setColor(this.colors.findIndex(e => e.name === name));
        }
      } else {
        this.setColor(index);
      }
    }
  }

/**
     * Deletes a pending transaction from the service. Normally called after detecting that an
     * offline transaction has been successfully published.
     */
    public async deletePendingTransaction(transactionKey: string): Promise<void> {
        Logger.log("wallet", `Deleting multisig transaction ${transactionKey}`);

        let requestUrl = `${environment.EssentialsAPI.serviceUrl}/multisig/transaction?key=${transactionKey}`;
        try {
            await this.jsonRPCService.httpDelete(requestUrl);
            return;
        }
        catch (err) {
            Logger.error('wallet', 'Multisig: fetchPendingTransaction() error:', err)
            return;
        }
    }

loadDataObservable(): Observable<any> {
    return this.http.get(`${environment.api}institutions`).pipe(
      switchMap((data) => {
        return of({
          csvData: this.parseJSON2CSV(data),
          jsonData: data,
        });
      })
    );
  }

// Generic file download via POST
  // download(path: string, filename: string, andDelete: boolean) {
  //   // console.debug('download', path, filename, andDelete)
  //   // const params = new HttpParams().set('path', path).set('delete', andDelete ? '1' : '0')
  //   // return this.http.get<Blob>(environment.proxyApi + '/download', { params, /*responseType: 'blob'*/ })
  //   return this.http.post(environment.proxyApi + '/download', { path, filename, andDelete }, { responseType: 'blob' })
  // }

  downloadBackup() {
    return this.http.post(environment.proxyApi + '/downloadBackup', {}, { responseType: 'blob' })
  }

onCancel() {
    if (this.sessionId && environment.production) {
      this.scannerApi.stopSession(this.sessionId).subscribe(data => {
        console.log(data);
        this.stepper.reset();
      }, err => {
        console.log(err);
        // Refresh the page to reconnect with the active session, if any
        window.location.reload();
      });
    } else {
      this.sessionId = undefined;
      this.stepper.reset();
    }
  }

setNetwork() {

    switch (environment.network) {
      case 'TESTNET':
        this.thorchainNetworkService.setNetwork(THORChainNetwork.TESTNET);
        break;

      default:
        this.thorchainNetworkService.setNetwork(THORChainNetwork.CHAOSNET);
        break;
    }

  }

@NgModule({
  declarations: [
    AppComponent,
  ],
  entryComponents: [],
  imports: [
    BrowserModule, 
    IonicModule.forRoot({
      // toastEnter: customAlertEnter
    }), 
    AppRoutingModule,
    AngularFireModule.initializeApp(environment.firebase),
    AngularFirestoreModule, 
    AngularFireStorageModule,
    AngularFireAuthModule,
    HttpModule,
    AngularFireAuthModule,
    FirebaseUIModule.forRoot(firebaseUiAuthConfig),
  ],
  providers: [
    Keyboard,
    GoogleMaps,
    NativeStorage,
    GooglePlus,
    StatusBar,
    SplashScreen,
    UserService,
    AngularFirestore,
    { provide: RouteReuseStrategy, useClass: IonicRouteStrategy }
  ],
  bootstrap: [AppComponent]
})
export class AppModule {}

/**
	 * Create a single purpose connection to the websocket.
	 *
	 * A WebSocket connection will be created, then an event will be sent;
	 * the connection remains active until the server closes it.
	 */
	createSinglePurposeConnection<T>(eventName: string, payload?: any): Observable<WebSocketService.SinglePurposePacket<T>> {
		return new Observable<WebSocketService.SinglePurposePacket<T>>(observer => {
			const ws = new WebSocket(environment.wsUrl); // Establish websocket connection

			ws.onopen = () => {
				this.logger.info(`<WS> Connected to ${environment.wsUrl}`);

				ws.onmessage = ev => { // Listen for messages
					let data: WebSocketService.SinglePurposePacket<T> | undefined;
					try { // Parse JSON
						data = JSON.parse(ev.data) as WebSocketService.SinglePurposePacket<T>;
					} catch (err) { observer.error(err); }
					if (!data) return undefined;

					// Emit the packet
					observer.next(data);

					return undefined;
				};

				// Listen for closure
				ws.onclose = ev => {
					if (ev.code === 1000)
						observer.complete();
					else
						observer.error(new WebSocketService.NonCompleteClosureError(ev.code, ev.reason));
				};

				// Send the event, requesting the server to begin sending us data
				ws.send(JSON.stringify({ type: eventName, payload }));
			};
		});
	}

ngOnInit() {
        const that = this;
        this.formAPIURL = environment.API_Gateway_Endpoint + '/user-forms';
        if (this.docid === 'NEW') {
            this.frm = new Form();
            this.frm.staticcaptcha = that.tabsSVC.getGUID();
            this.tabsSVC.setTabTitle(this.tabid, 'New Form');
            this.loading = false;
            setTimeout(() => { that.setLoading(false); }, 1000); // delay to prevent error
            // enable trumbowyg editor onchange tracking
            setTimeout(() => { that.editorTrackChanges = true; }, 2000);
        } else {
            this.loadByID(this.docid);
        }
    }

handleAuth(type: string) {
    console.log(type);
    //github oauth配置
    const config = {
      oauth_uri: 'https://github.com/login/oauth/authorize',
      redirect_uri: 'https://devui.design/admin/login',
      client_id: 'ef3ce924fcf915c50910',
    };
    if (!environment.production) {
      config.redirect_uri = 'http://localhost:8001/login';
      config.client_id = 'ecf5e43d804e8e003196';
    }
    window.location.href = `${config.oauth_uri}?client_id=${config.client_id}&redirect_uri=${config.redirect_uri}`;
  }

public showLoginForm(opts: any): void {
        const lastuser = localStorage.getItem(environment.lastuservar) || '';
        const dialogRef = this.dialog.open(LoginDialogComponent, { width: '450px', disableClose: true, data: { email: lastuser } });

        dialogRef.afterClosed().subscribe(result => {
            if (result.action === 'close') { return; }
            if (result.action === 'success') {
                if (opts.onSuccessReload) {
                    console.log('reloading window after login');
                    window.location.reload();
                }
            }
        });
    }

baseUrl = environment.apiUrl

constructor(
    private userService: UserService,
    private deviceService: DeviceService,
    private httpClient: HttpClient,
    private deepLinkService: DeepLinkService
  ) {
    this.ROOT_ENDPOINT = environment.ROOT_URL;
  }

/**
   * Método responsável por criar um 'New Employee'
   */
  createNewEmployee(employee: Employee): Observable<any> {
    // ==> (POST - url no Back-End): http://locahost:3000/api/employees
    return this.http.post(`${environment.baseUrl}/employees`, employee);
  }

@NgModule({
  declarations: [
    AppComponent,
    PersonContactComponent,
    PartyFormComponent,
    EventFormComponent,
    TagsListComponent,
    NgModelDemoComponent,
    PeopleComponent,
  ],
  imports: [
    BrowserModule,
    ReactiveFormsModule,
    BrowserAnimationsModule,
    MatFormFieldModule,
    MatCommonModule,
    MatInputModule,
    MatButtonModule,
    MatDatepickerModule,
    MatNativeDateModule,
    ShowFormControlModule.for(environment.production ? 'prod' : 'dev'),
    MatIconModule,
    MatDividerModule,
    MatProgressSpinnerModule,
    FormsModule,
    RouterModule.forRoot([
      {
        path: 'party',
        component: PartyFormComponent,
      },
      {
        path: 'ngmodel',
        component: NgModelDemoComponent,
      },
      {
        path: 'tags',
        component: TagsListComponent,
      },
      {
        path: 'people',
        component: PeopleComponent,
      },
      {
        path: '**',
        redirectTo: 'party',
      },
    ]),
    MatCardModule,
  ],
  providers: [],
  bootstrap: [AppComponent],
})
export class AppModule {}

environment = environment;

// private baseUrl = '/assets/data/blogs.json';
  private blogUrl = environment.herokuConfig.blogURL;

public env = environment;

constructor(private http: HttpClient) {
    this.apiUrl = environment.apiUrl + 'users';
  }

public deleteOrder(id: number): Observable<void> {
    return this.http.delete<void>(`${environment.ordersEndpoint}/${id}`)
      .pipe(
        catchError(this.handleError)
      );
  }

performPowerTunerStepFunction(application: TunerPayload): Observable<PowerTunerToken> {
    return this.httpClient.post<PowerTunerToken>(`${environment.apiGatewayBaseUrl}/power-tuner`, application);
  }