Top 10 Examples of "ng2-logger in functional component" in JavaScript

import { Component, OnInit, OnDestroy } from '@angular/core';
import { Log } from 'ng2-logger';

import { RpcStateService } from '../../../../core/rpc/rpc-state/rpc-state.service';

@Component({
  selector: 'app-timeoffset',
  templateUrl: './timeoffset.component.html',
  styleUrls: ['./timeoffset.component.scss']
})
export class TimeoffsetComponent implements OnInit, OnDestroy {

  // general
  private log: any = Log.create('status.component');
  private destroyed: boolean = false;

  // state
  public offset: number = 0;

  constructor(
    private _rpcState: RpcStateService) { }

  ngOnInit() {
    this._rpcState.observe('getnetworkinfo', 'timeoffset')
      .takeWhile(() => !this.destroyed)
      .subscribe(offset => this.offset = offset);
  }

  ngOnDestroy() {
    this.destroyed = true;

import * as _ from 'lodash';
import * as io from 'socket.io-client';

import { Global } from '../global-config';
import { SYMBOL } from '../symbols';

import { Log, Level } from 'ng2-logger';
import { Helpers } from '../helpers';
import { BASE_ENTITY } from '../framework/framework-entity';
import { CLASS } from 'typescript-class-helpers';
import { RealtimeHelper } from './realtime-helper';
const log = Log.create('RealtimeBrowser', Level.__NOTHING)

export type AliasChangeListenerType = (unsubscribe: () => void) => void;
export type AliasEntityType = Partial>;

export class RealtimeBrowser {
  private static connected = false;
  static init() {
    if (RealtimeBrowser.connected) {
      log.warn('BROWSER ALREADY CONNECTED!')
      return
    }
    RealtimeBrowser.connected = true;
    // RealtimeHelper.pathFor(SYMBOL.REALTIME.NAMESPACE).hostname
    const nspPath = {
      global: RealtimeHelper.pathFor(),
      realtime: RealtimeHelper.pathFor(SYMBOL.REALTIME.NAMESPACE)

import * as _ from 'lodash';
// import { HttpMethod, MethodConfig, ClassConfig } from 'ng2-rest';

//#region @backend
import { Http2Server } from 'http2';
import * as io from 'socket.io';
import { Response, Request } from 'express';
import { SYMBOL } from '../symbols';
//#endregion

import { Log, Level } from 'ng2-logger';
import { BASE_ENTITY } from '../framework/framework-entity';
import { Helpers } from '../helpers';
import { RealtimeHelper } from './realtime-helper';
import { CLASS } from 'typescript-class-helpers';
const log = Log.create('RealtimeNodejs', Level.__NOTHING)

export class RealtimeNodejs {
  //#region @backend
  static init(http: Http2Server) {

    const nspPath = {
      global: RealtimeHelper.pathFor(),
      realtime: RealtimeHelper.pathFor(SYMBOL.REALTIME.NAMESPACE)
    };


    Global.vars.socketNamespace.BE = io(http, {
      path: nspPath.global.pathname
    });

import { RpcService } from '../../../core/core.module';
import { SnackbarService } from '../../../core/snackbar/snackbar.service';

/* fix wallet */
import { FixWalletModalComponent } from 'app/wallet/wallet/send/fix-wallet-modal/fix-wallet-modal.component';
import { TransactionBuilder } from './transaction-builder.model';

/*
  Note: due to upcoming multiwallet, we should never ever store addresses in the GUI for transaction purposes.
  e.g the stealth address for balance transfer has to be fetched _every_ time a transaction is executed.
*/

@Injectable()
export class SendService {

  log: any = Log.create('send.service');

  constructor(private _rpc: RpcService,
              private flashNotification: SnackbarService,
              private dialog: MatDialog) {

  }

  /* Sends a transaction */
  public sendTransaction(tx: TransactionBuilder) {
    tx.estimateFeeOnly = false;

    this.send(tx)
      .subscribe(
        success => this.rpc_send_success(success, tx.toAddress, tx.amount),
        error => this.rpc_send_failed(error.message, tx.toAddress, tx.amount));
  }

import { Injectable, OnDestroy } from '@angular/core';
import { Observable, Observer } from 'rxjs';
import { Log } from 'ng2-logger';

import { RpcService } from 'app/core/rpc/rpc.service';

@Injectable()
export class ConnectionCheckerService implements OnDestroy {

  log: any = Log.create('connection-checker.service id:' + Math.floor((Math.random() * 1000) + 1));
  destroyed: boolean = false;

  checkInterval: number = 1 * 1000; // milliseconds

  check: Observable;
  observer: Observer;

  // shareReplay
  constructor(private rpc: RpcService) {
    this.log.d(`connection-checker created`);
    this.check = Observable.create(observer => {
      this.observer = observer;
    }).shareReplay();
  }

  /**

import { Injectable, OnDestroy } from '@angular/core';
import { Log } from 'ng2-logger';

import { Bid } from '../api/bid/bid.model';
import { MarketStateService } from 'app/core/market/market-state/market-state.service';
import { Listing } from 'app/core/market/api/listing/listing.model';

@Injectable()
export class AddToCartCacheService implements OnDestroy {

  private log: any = Log.create('add-to-cart-cache.service id:' + Math.floor((Math.random() * 1000) + 1));
  public orders: Array = new Array();
  private destroyed: boolean = false;
  constructor(
    private marketState: MarketStateService
  ) {
    this.update();
    // subscribe to changes
    this.getBids().takeWhile(() => !this.destroyed).subscribe(orders => {
      this.orders = orders;
    });
   }

  isBidded(listing: Listing): boolean {
    if (listing) {
      return this.orders.filter(order => order.OrderItem.itemHash)
                        .map(o => o.OrderItem.itemHash)

import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';

import { Log, Level } from 'ng2-logger';
const log = Log.create('app module');
// Log.setProductionMode()
// Log.setProductionMode()
// Log.onlyLevel(Level.ERROR)
// Log.onlyLevel(Level.WARN)
// Log.onlyModules( new RegExp('.*component') )
// Log.onlyModules( 'app module')

// log.fixedWidth = 200;

log.i('module!')
log.er('moduleer r')

import { AppComponent } from './app.component';


@NgModule({

SyncingComponent,
    UnlockwalletComponent,
    EncryptwalletComponent
  ]
})
export class ModalsComponent implements DoCheck, OnInit {

  @ViewChild('modalContainer', { read: ViewContainerRef })
  private modalContainer: ViewContainerRef;

  modal: ComponentRef;
  hasScrollY: boolean = false;
  closeOnEscape: boolean = true;
  enableClose: boolean;
  loadSpinner: boolean;
  private logger: any = Log.create('modals.component');

  constructor(
    private _element: ElementRef,
    private _resolver: ComponentFactoryResolver,
    public _dialogRef: MdDialogRef,
    private state: StateService) {
  }

  ngOnInit() {
    this.state.observe('modal:fullWidth:enableClose')
      .subscribe(status => this.enableClose = status);

    this.state.observe('ui:spinner')
      .subscribe(status => this.loadSpinner = status);
  }

//#region @backend
console.log('heeloa')
import * as path from 'path';
import * as _ from "lodash";
import "reflect-metadata";
import { createConnection, useContainer } from 'typeorm';
//#endregion

import { init, ENDPOINT, GET, Response } from 'morphi';



import { Log, Level } from 'ng2-logger';
const log = Log.create('main application')
const log2 = Log.create('auth module')
const log3 = Log.create('books module')
const log4 = Log.create("/Users/test/Projects/testProject/index.ts")
export class User {
  name: string;
  id: number;
  friend: User;
}


@ENDPOINT({ path: '/hello' })
export class UserController {

  @GET('/')
  hello(): Response {
    let user = new User();

console.log('heeloa')
import * as path from 'path';
import * as _ from "lodash";
import "reflect-metadata";
import { createConnection, useContainer } from 'typeorm';
//#endregion

import { init, ENDPOINT, GET, Response } from 'morphi';



import { Log, Level } from 'ng2-logger';
const log = Log.create('main application')
const log2 = Log.create('auth module')
const log3 = Log.create('books module')
const log4 = Log.create("/Users/test/Projects/testProject/index.ts")
export class User {
  name: string;
  id: number;
  friend: User;
}


@ENDPOINT({ path: '/hello' })
export class UserController {

  @GET('/')
  hello(): Response {
    let user = new User();
    return { send: user }
  }