TypeScript effects.EffectsModule類代碼示例

const testModuleConfig = () => {
  TestBed.configureTestingModule({
    imports: [
      CoreModule,
      RouterTestingModule,
      AnalyticsModule,
      MultilingualModule,
      StoreModule.provideStore({ sample: reducer }),
      EffectsModule.run(NameListEffects)
    ],
    declarations: [HomeComponent, TestComponent],
    providers: [
      NameListService,
      BaseRequestOptions,
      MockBackend,
      {
        provide: Http, useFactory: function (backend: ConnectionBackend, defaultOptions: BaseRequestOptions) {
          return new Http(backend, defaultOptions);
        },
        deps: [MockBackend, BaseRequestOptions]
      }
    ]
  });
};

import { LoginPage } from '../pages/user/login';
import { CreateAccountPage } from '../pages/createAccount/createAccount';
import { ListStuffPage } from '../pages/listStuff/listStuff';
import { AddStuffModal } from '../pages/listStuff/addStuffModal';

// PROVIDERS 
import { Authentication } from '../providers/authentication'

import { AuthenticationReducer } from './../reducers/authentication';
import { StoreModule } from '@ngrx/store';
import { EffectsModule } from '@ngrx/effects';
import { StoreDevtoolsModule } from '@ngrx/store-devtools';


const appEffectsRun = [
  EffectsModule.run(AuthEffects),
  EffectsModule.run(TodoEffects),
];

@NgModule({
  declarations: [
    MyApp,
    HomePage,
    CreateAccountPage,
    LoginPage,
    ListStuffPage,
    AddStuffModal
  ],
  imports: [
    IonicModule.forRoot(MyApp),
    StoreModule.provideStore({ auth: AuthenticationReducer, todos: TodoReducer }),

import { BootEffects } from "./boot.effect";
import { PatientEffects } from './patient.effect';
import { SessionsEffects } from './sessions.effect';
import { PaymentsEffects } from './payments.effect';
import { PatientsEffects } from './patients.effect';
import { StoreEffects } from './store.effect';
import { StoreActionsEffects } from './storeActions.effect';
import { DiaryEffects } from './diary.effect';
import { MessagesEffects } from './messages.effect';
import { BackupEffects } from './backup.effect';
import { AppointmentsEffects } from './appointments.effect';
import { SearchsEffects } from './searchs.effect';
import { AuthEffects } from './auth.effect';

export const EFFECTS = EffectsModule.forRoot([
	PatientEffects,
	SessionsEffects,
	StoreEffects,
	StoreActionsEffects,
	DiaryEffects,
	MessagesEffects,
	PaymentsEffects,
	BackupEffects,
	PatientsEffects,
	AppointmentsEffects,
	SearchsEffects,
	AuthEffects,
	BootEffects, // Should always remain last https://github.com/ngrx/platform/issues/103#issuecomment-316813618
]);

  profile: IProfile;
  weather: IWeather;
}

// all new reducers should be define here
const reducers = {
  feed: feedReducer,
  profile: profileReducer,
  weather: weatherReducer
};

const productionReducer: ActionReducer<IAppState> = combineReducers(reducers);
const developmentReducer: ActionReducer<IAppState> = compose(storeFreeze, combineReducers)(reducers);

export function reducer(state: IAppState, action: Action) {
  if (environment.production) {
    return productionReducer(state, action);
  } else {
    return developmentReducer(state, action);
  }
}

export const store: ModuleWithProviders = StoreModule.provideStore(reducer);
export const instrumentation: ModuleWithProviders =  (!environment.production) ? StoreDevtoolsModule.instrumentOnlyWithExtension() : null;

export const effects: ModuleWithProviders[] = [
  EffectsModule.run(ProfileEffects),
  EffectsModule.run(FeedEffects),
  EffectsModule.run(WeatherEffects)
];

import { EffectsModule } from '@ngrx/effects';
import { TenantEffects } from './tenant.effects';

export const EFFECTS = [
  EffectsModule.run(TenantEffects),
];

function heroesComponentClassSetup() {
  TestBed.configureTestingModule({
    imports: [StoreModule.forRoot({}), EffectsModule.forRoot([]), CoreModule, EntityStoreModule],
    providers: [
      Actions,
      AppEntityServices,
      AppSelectors,
      HeroesComponent, // When testing class-only
      HeroesService,
      { provide: HttpClient, useValue: null },
      { provide: NgrxDataToastService, useValue: null }
    ]
  });

  // Component listens for toggle between local and remote DB
  const appSelectorsDataSource = new BehaviorSubject('local');
  const appSelectors: AppSelectors = TestBed.get(AppSelectors);
  spyOn(appSelectors, 'dataSource$').and.returnValue(appSelectorsDataSource);

  // Create Hero entity actions as ngrx-data will do it
  const entityActionFactory: EntityActionFactory = TestBed.get(EntityActionFactory);
  function createHeroAction(op: EntityOp, data?: any, options?: EntityActionOptions) {
    return entityActionFactory.create('Hero', op, data, options);
  }

  // Spy on EntityEffects
  const effects: EntityEffects = TestBed.get(EntityEffects);
  let persistResponsesSubject: ReplaySubject<Action>;

  const persistSpy = spyOn(effects, 'persist').and.callFake(
    (action: EntityAction) => (persistResponsesSubject = new ReplaySubject<Action>(1))
  );

  // Control EntityAction responses from EntityEffects spy
  function setPersistResponses(...actions: Action[]) {
    actions.forEach(action => persistResponsesSubject.next(action));
    persistResponsesSubject.complete();
  }

  // Sample Hero test data
  const initialHeroes = [
    { id: 1, name: 'A', saying: 'A says' },
    { id: 3, name: 'B', saying: 'B says' },
    { id: 2, name: 'C', saying: 'C says' }
  ];

  // Spy on dispatches to the store (not very useful)
  const testStore: Store<EntityCache> = TestBed.get(Store);
  const dispatchSpy = spyOn(testStore, 'dispatch').and.callThrough();

  return {
    appSelectorsDataSource,
    createHeroAction,
    dispatchSpy,
    effects,
    entityActionFactory,
    initialHeroes,
    persistResponsesSubject,
    persistSpy,
    setPersistResponses,
    testStore
  };
}

import { EffectsModule } from '@ngrx/effects';

import { AppPlayerEffects } from './app-player.effects';
import { NowPlaylistEffects } from './now-playlist.effects';
import { UserProfileEffects } from './user-profile.effects';
import { PlayerSearchEffects } from './player-search.effects';
import { AppSettingsEffects } from './app-settings.effects';
import { RouterEffects } from './router.effects';

export const AppEffectsModules = EffectsModule.forRoot([
  AppPlayerEffects,
  NowPlaylistEffects,
  UserProfileEffects,
  PlayerSearchEffects,
  AppSettingsEffects,
  RouterEffects
]);

import { routes } from './app.routing';
import { rootReducer } from './reducers';
import { StoreDevToolsModule } from './features/store-devtools.module';
import { UserEffects } from './user/user.effects';

const STORE_DEV_TOOLS_IMPORTS = [];
if (ENV === 'development' && !AOT &&
  ['monitor', 'both'].includes(STORE_DEV_TOOLS) // set in constants.js file in project root
) STORE_DEV_TOOLS_IMPORTS.push(...[
  StoreDevtoolsModule.instrumentStore({
    monitor: useLogMonitor({
      visible: true,
      position: 'right'
    })
  })
]);

export const APP_IMPORTS = [
  EffectsModule.run(UserEffects),
  MaterialModule.forRoot(),
  ReactiveFormsModule,
  IdlePreloadModule.forRoot(), // forRoot ensures the providers are only created once
  RouterModule.forRoot(routes, { useHash: false, preloadingStrategy: IdlePreload }),
  RouterStoreModule.connectRouter(),
  StoreModule.provideStore(rootReducer),
  STORE_DEV_TOOLS_IMPORTS,
  StoreDevToolsModule
];

import { EffectsModule } from '@ngrx/effects';

import { RequestEffect } from '../effects/request.effect';

export const EffectsModuleImport = EffectsModule.forRoot([
  RequestEffect
]);

const productionReducer: ActionReducer<IAppState> = combineReducers(reducers);
const developmentReducer: ActionReducer<IAppState> = compose(storeFreeze, combineReducers)(reducers);

export function reducer(state: IAppState, action: Action) {
  if (environment.production) {
    return productionReducer(state, action);
  } else {
    return developmentReducer(state, action);
  }
}

@NgModule()
export class DummyModule {

  static forRoot(): ModuleWithProviders {
    return {
      ngModule: CommonModule
    };
  }
}

export const store: ModuleWithProviders = StoreModule.provideStore(reducer);
export const instrumentation: ModuleWithProviders =
  (!environment.production) ? StoreDevtoolsModule.instrumentOnlyWithExtension() : DummyModule.forRoot();

export const effects: ModuleWithProviders[] = [
  EffectsModule.run(ProfileEffects),
  EffectsModule.run(FeedEffects)
];