TypeScript static.downgradeInjectable函數代碼示例

  it('should run all the tests, checking that the messages are right', (done) => {

    // TODO: ANG, once we get a pattern established, module creation should be extracted to helpers.js
    @NgModule({
      imports: [BrowserModule, UpgradeModule],
      providers: [
        DummyNg2Service
      ]
    })
    class TestModule {
      public ngDoBootstrap() {}
    }

    // TODO: ANG, once we get a pattern established, downgraded module creation should be extracted to helpers.js
    const mod: any =
      angular.module(DUMMY_NG2_SERVICE, []).factory(DUMMY_DOWNGRADE.injectionName, downgradeInjectable(DummyNg2Service));
    bootstrap(platformBrowserDynamic(), TestModule, html('<div>'), [mod.name, DUMMY_NG1_SERVICE])
      .then((upgrade) => {
        const injector: any = upgrade.$injector;
        const dummyNg2Service: DummyNg2Service = injector.get(DUMMY_DOWNGRADE.injectionName) as DummyNg2Service;
        expect(dummyNg2Service).toBeDefined();
        expect(dummyNg2Service.getMessage()).toBe('Dummy NG2 Service');

        const dummyNg1Service: DummyNg1Service = injector.get('dummyNg1Service') as DummyNg1Service;
        expect(dummyNg1Service).toBeDefined();
        expect(dummyNg1Service.getMessage()).toBe('Dummy NG1 Service');
        expect(dummyNg1Service.getInjectedMessage()).toBe('Dummy NG2 Service');
        done();
      });
  });

    it('should downgrade ng2 service to ng1', async(() => {
         // Tokens used in ng2 to identify services
         const Ng2Service = new OpaqueToken('ng2-service');

         // Sample ng1 NgModule for tests
         @NgModule({
           imports: [BrowserModule, UpgradeModule],
           providers: [
             {provide: Ng2Service, useValue: 'ng2 service value'},
           ]
         })
         class Ng2Module {
           ngDoBootstrap() {}
         }

         // create the ng1 module that will import an ng2 service
         const ng1Module =
             angular.module('ng1Module', []).factory('ng2Service', downgradeInjectable(Ng2Service));

         bootstrap(platformBrowserDynamic(), Ng2Module, html('<div>'), ng1Module)
             .then((upgrade) => {
               const ng1Injector = upgrade.$injector;
               expect(ng1Injector.get('ng2Service')).toBe('ng2 service value');
             });
       }));

  removeEdge(db, user, e){
    this.init(db, user);
    this.databases[db][user].data.edges = this.databases[db][user].data.edges.filter((edge) => {
      return edge["@rid"] !== e.edge["@rid"];
    })
  },
  removeVertex(db, user, v){
    this.init(db, user);
    this.databases[db][user].data.vertices = this.databases[db][user].data.vertices.filter((vertex) => {
      return vertex["@rid"] !== v["@rid"];
    })
  },
  data(db, user){
    this.init(db, user);
    return this.databases[db][user].data;
  },
  clear(db, user) {
    this.databases[db][user].data = {vertices: [], edges: []};
  }
});

angular.module('graph.services', []).factory(
  `GraphService`,
  downgradeInjectable(GraphService));

export  {GraphService};

  .component('lMdContent', MdContentComponent)
  .component('lMdToolbar', MdToolbarComponent)
  .component('lMdSidenav', MdSidenavComponent)
  .component('lMdIcon', MdIconComponent)
  .component('lMdProgressLinear', MdProgressLinearComponent)
  .component('lMdCard', MdCardComponent)

  // angular 1 app services
  .service('lMenuService', MenuService)
  .service('lLineItemService', LineItemService)
  .service('lOrderService', OrderService)
  .service('lBasketService', BasketService)
  .service('lUserService', UserService)
  .service('lToastService', ToastService)
  .service('lPriceService', PriceService)
  .factory('router', downgradeInjectable(RouterWrapper))
  .factory('configService', downgradeInjectable(ConfigService))

  // angular 1 app filters
  .filter('lDate', DateFilter)

  // angular 2 app components to be used in angular 1 app
  .directive('lApp', downgradeComponent({component: AppComponent}) as angular.IDirectiveFactory)
  .directive('lExample', downgradeComponent({component: ExampleComponent}) as angular.IDirectiveFactory)
  .directive('lFlashMessage', downgradeComponent({component: FlashMessageComponent}) as angular.IDirectiveFactory)
  .directive('lPastDaysSwitcher', downgradeComponent({
    component: PastDaysSwitcherComponent,
    inputs: ['switched'],
    outputs: ['switch']
  }) as angular.IDirectiveFactory)
  .directive('lMenuCover', downgradeComponent({

import {downgradeInjectable} from '@angular/upgrade/static';
import {Injectable} from "@angular/core";

declare var angular: any;

@Injectable()
export class FormatArrayPipe {

  transform(input) {
    if (input instanceof Array) {
      var output = "";
      input.forEach(function (e, idx) {
        output += (idx > 0 ? ", " : " ") + e;
      })
      return output;
    } else {
      return input;
    }
  }
}

angular.module('legacy.filters', []).factory(
  `FormatArrayPipe`,
  downgradeInjectable(FormatArrayPipe));

import { heroDetailComponent } from './hero-detail.component';

// #docregion ngmodule, register
import { Heroes } from './heroes';
// #enddocregion register

@NgModule({
  imports: [
    BrowserModule,
    UpgradeModule
  ],
  providers: [ Heroes ]
})
export class AppModule {
  constructor(private upgrade: UpgradeModule) { }
  ngDoBootstrap() {
    this.upgrade.bootstrap(document.body, ['heroApp'], { strictDi: true });
  }
}
// #enddocregion ngmodule
// #docregion register
import { downgradeInjectable } from '@angular/upgrade/static';

angular.module('heroApp', [])
  .factory('heroes', downgradeInjectable(Heroes))
  .component('heroDetail', heroDetailComponent);
// #enddocregion register

platformBrowserDynamic().bootstrapModule(AppModule);

        this._hubConnection = new HubConnection('/myvotehub');

        this._hubConnection.on('pollAdded',
            (...msg: any[]) => {
                if (this.pollAddedObserver) {
                    this.pollAddedObserver.next(msg[0]);
                }
            });

        this._hubConnection.start()
            .then(() => {
                console.log('MyVoteHub connection started');
            })
            .catch(err => {
                console.log('Error while establishing connection');
            });

        this.pollAddedChanged$ = new Observable((observer: any) => this.pollAddedObserver = observer).share();
    }

    public addPollNotification(): void {
        //Invoking 'AddPollAsync' method defined in SignalR hub
        this._hubConnection.invoke('AddPollAsync');
    }

}

angular.module('MyVoteApp')
    .factory('ngSignalRService', downgradeInjectable(SignalRService));

        outputs: ['checkedChange']
    }));
    SdcUiComponentsNg1Module.directive('sdcRadioGroup', downgradeComponent({
        component: Components.RadioGroupComponent,
        inputs: ['legend', 'options', 'disabled', 'value', 'direction'],
        outputs: ['valueChange']
    }));

    // Buttons
    SdcUiComponentsNg1Module.directive('sdcButton', downgradeComponent({
        component: Components.ButtonComponent,
        inputs: ['text', 'disabled', 'type', 'size', 'preventDoubleClick', 'icon_name', 'icon_positon']
    }));

    // Modals
    SdcUiComponentsNg1Module.service('SdcModalService', downgradeInjectable(Components.ModalService));
    SdcUiComponentsNg1Module.directive('sdcModal', downgradeComponent({
        component: Components.ModalComponent,
        inputs: ['size', 'title', 'message', 'buttons', 'type'],
        outputs: ['closeAnimationComplete']
    }));
    SdcUiComponentsNg1Module.directive('sdcModalButton', downgradeComponent({
        component: Components.ModalButtonComponent,
        inputs: ['callback', 'closeModal']
    }));

    // Notifications
    SdcUiComponentsNg1Module.service('SdcNotificationService', downgradeInjectable(Components.NotificationsService));
    SdcUiComponentsNg1Module.directive('sdcNotificationContainer', downgradeComponent({
        component: Components.NotificationContainerComponent
    }));

SPINNAKER_DOWNGRADES.forEach((item) => {
  DOWNGRADED_MODULE_NAMES.push(item.moduleName);
  providers.push(item.moduleClass);
  angular.module(item.moduleName, []).factory(item.injectionName, downgradeInjectable(item.moduleClass));
});

  status() {
    let url = API + 'etl/status';
    return this.http.get(url).toPromise().then((data) => {
      return data.json();
    });
  }

  saveConfiguration(params) {
    let url = API + 'etl/save-config';
    return this.http.post(url, params).toPromise().then((data) => {
      return data.json();
    });
  }

  initDatabase2Configs() {
    let url = API + 'etl/list-configs';
    return this.http.post(url, undefined).toPromise().then((data) => {
      return data.json();
    });
  }

}


angular.module('command.services', []).factory(
  `EtlService`,
  downgradeInjectable(EtlService));

export {EtlService};