Merge branch 'master' into bump-flex-layout

Author: jotatoledo

src/app/app.component.spec.ts

@@ -2,16 +2,17 @@ import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { RouterTestingModule } from '@angular/router/testing';
 import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
 import { MatSidenavModule, MatListModule } from '@angular/material';
+
 import { TranslateModule } from '@ngx-translate/core';
 
 import { AppComponent } from './app.component';
 import { CoreModule } from './core/core.module';
-import { LanguageService } from './core/services/language.service';
+import { OperatorMenuService } from './core/services/operator-menu.service';
 
 describe('AppComponent', () => {
   let component: AppComponent;
   let fixture: ComponentFixture<AppComponent>;
-  let languageService: LanguageService;
+  let operatorMenuService: OperatorMenuService;
 
   beforeEach(() => {
     TestBed.configureTestingModule({
@@ -24,19 +25,28 @@ describe('AppComponent', () => {
         TranslateModule.forRoot()
       ],
       declarations: [AppComponent],
-      providers: [LanguageService]
+      providers: [OperatorMenuService]
     });
 
+    operatorMenuService = TestBed.get(OperatorMenuService);
     fixture = TestBed.createComponent(AppComponent);
     component = fixture.componentInstance;
-    languageService = TestBed.get(LanguageService);
+    fixture.detectChanges();
   });
 
-  it('should init supported languages on initialization', () => {
-    spyOn(languageService, 'init').and.stub();
+  it('should call openOperatorMenu on shouldOpenChildMenu if condition is true', () => {
+    spyOn(operatorMenuService, 'openOperatorMenu').and.stub();
 
-    fixture.detectChanges();
+    component.shouldOpenChildMenu('MENU.OPERATORS');
+
+    expect(operatorMenuService.openOperatorMenu).toHaveBeenCalled();
+  });
+
+  it('should not call openOperatorMenu on shouldOpenChildMenu if condition is false', () => {
+    spyOn(operatorMenuService, 'openOperatorMenu').and.stub();
+
+    component.shouldOpenChildMenu('MENU.HOME');
 
-    expect(languageService.init).toHaveBeenCalledWith(['en', 'ru']);
+    expect(operatorMenuService.openOperatorMenu).not.toHaveBeenCalled();
   });
 });

src/app/app.component.ts

@@ -8,7 +8,6 @@ import {
 import { filter, map, mergeMap } from 'rxjs/operators';
 import { SeoService, SeoData } from './core/services/seo.service';
 import { OperatorMenuService } from './core/services/operator-menu.service';
-import { LanguageService } from './core/services/language.service';
 
 interface Menu {
   title: string;
@@ -49,8 +48,7 @@ export class AppComponent implements OnInit {
     private _router: Router,
     private _activatedRoute: ActivatedRoute,
     private _seo: SeoService,
-    private _operatorMenuService: OperatorMenuService,
-    private languageService: LanguageService
+    private _operatorMenuService: OperatorMenuService
   ) {}
 
   ngOnInit() {
@@ -69,8 +67,6 @@ export class AppComponent implements OnInit {
         filter((data: SeoData) => data.title !== undefined)
       )
       .subscribe((data: SeoData) => this._seo.setHeaders(data));
-
-    this.languageService.init(['en', 'ru']);
   }
 
   shouldOpenChildMenu(title: string): void {

src/app/app.module.ts

@@ -13,7 +13,6 @@ import { CoreModule } from '../app/core/core.module';
 import { MaterialModule } from './material/material.module';
 import { AppRoutingModule } from './app-routing.module';
 import { AppComponent } from './app.component';
-import { LanguageService } from './core/services/language.service';
 
 export function HttpLoaderFactory(http: HttpClient) {
   return new TranslateHttpLoader(http);
@@ -40,7 +39,6 @@ export function HttpLoaderFactory(http: HttpClient) {
       }
     })
   ],
-  providers: [LanguageService],
   bootstrap: [AppComponent]
 })
 export class AppModule {}

src/app/core/components/toolbar/toolbar.component.spec.ts

@@ -10,12 +10,14 @@ import { MaterialModule } from '../../../material/material.module';
 import { LanguageService } from '../../services/language.service';
 import { TranslateModule } from '@ngx-translate/core';
 import { languagesList } from '../../data/language.data';
+import { OperatorsService } from '../../services/operators.service';
 
 describe('ToolbarComponent', () => {
   const languages = languagesList;
   let component: ToolbarComponent;
   let fixture: ComponentFixture<ToolbarComponent>;
   let languageService: LanguageService;
+  let operatorsService: OperatorsService;
 
   beforeEach(() => {
     TestBed.configureTestingModule({
@@ -26,10 +28,11 @@ describe('ToolbarComponent', () => {
         TranslateModule.forRoot()
       ],
       declarations: [ToolbarComponent],
-      providers: [LanguageService]
+      providers: [LanguageService, OperatorsService]
     });
 
     languageService = TestBed.get(LanguageService);
+    operatorsService = TestBed.get(OperatorsService);
     fixture = TestBed.createComponent(ToolbarComponent);
     component = fixture.componentInstance;
   });
@@ -50,15 +53,17 @@ describe('ToolbarComponent', () => {
     fixture.detectChanges();
 
     expect(component.languagesList).toEqual(languages);
-    expect(component.currentLang).toEqual(languages[1]);
   });
 
   it('should change current language on onLangSwitch', () => {
     spyOn(languageService, 'saveLang').and.stub();
+    spyOn(operatorsService, 'changeOperatorsLang').and.stub();
 
     component.onLangSwitch(languages[1]);
 
-    expect(component.currentLang).toEqual(languages[1]);
+    expect(operatorsService.changeOperatorsLang).toHaveBeenCalledWith(
+      languages[1]
+    );
     expect(languageService.saveLang).toHaveBeenCalledWith(languages[1]);
   });
 });

src/app/core/components/toolbar/toolbar.component.ts

@@ -1,6 +1,8 @@
 import { Component, OnInit, Output, EventEmitter } from '@angular/core';
+
 import { Lang } from '../../models/language.model';
 import { LanguageService } from '../../services/language.service';
+import { OperatorsService } from '../../services/operators.service';
 
 @Component({
   selector: 'app-toolbar',
@@ -9,22 +11,23 @@ import { LanguageService } from '../../services/language.service';
 })
 export class ToolbarComponent implements OnInit {
   @Output() navToggle = new EventEmitter<boolean>();
-  currentLang: Lang;
   languagesList: Lang[];
 
-  constructor(private languageService: LanguageService) {}
+  constructor(
+    private languageService: LanguageService,
+    private operatorsService: OperatorsService
+  ) {}
 
   ngOnInit() {
     this.languagesList = this.languageService.getLanguagesList();
-    this.currentLang = this.languageService.getCurrentLang();
   }
 
   navOpen() {
     this.navToggle.emit(true);
   }
 
   onLangSwitch(lang: Lang): void {
-    this.currentLang = lang;
     this.languageService.saveLang(lang);
+    this.operatorsService.changeOperatorsLang(lang);
   }
 }

src/app/core/core.module.ts

@@ -8,6 +8,8 @@ import { SeoService } from './services/seo.service';
 import { OperatorMenuService } from './services/operator-menu.service';
 import { ToolbarComponent } from './components/toolbar/toolbar.component';
 import { MaterialModule } from '../material/material.module';
+import { OperatorsService } from './services/operators.service';
+import { LanguageService } from './services/language.service';
 
 @NgModule({
   imports: [FlexLayoutModule, RouterModule, CommonModule, MaterialModule],
@@ -18,7 +20,13 @@ export class CoreModule {
   static forRoot() {
     return {
       ngModule: CoreModule,
-      providers: [CopierService, SeoService, OperatorMenuService]
+      providers: [
+        CopierService,
+        SeoService,
+        OperatorMenuService,
+        OperatorsService,
+        LanguageService
+      ]
     };
   }
 }

src/app/core/services/language.service.ts

@@ -1,5 +1,7 @@
 import { Injectable } from '@angular/core';
+
 import { TranslateService } from '@ngx-translate/core';
+
 import { Lang } from '../models/language.model';
 import { languagesList } from '../data/language.data';
 
@@ -9,6 +11,7 @@ export class LanguageService {
 
   constructor(private translate: TranslateService) {
     this.fullLangList = languagesList;
+    this.init(['en', 'ru']);
   }
 
   init(languages: string[]): void {

src/app/core/services/operators.service.spec.ts

@@ -0,0 +1,47 @@
+import { TestBed, tick, fakeAsync } from '@angular/core/testing';
+import { TranslateModule } from '@ngx-translate/core';
+
+import { LanguageService } from './language.service';
+import { OperatorsService } from './operators.service';
+
+describe('OperatorsService', () => {
+  let operatorsService: OperatorsService;
+  let languageService: LanguageService;
+  const lang = {
+    code: 'en',
+    name: 'English',
+    nativeName: 'English'
+  };
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [TranslateModule.forRoot()],
+      providers: [OperatorsService, LanguageService]
+    });
+
+    operatorsService = TestBed.get(OperatorsService);
+    languageService = TestBed.get(LanguageService);
+  });
+
+  it('should set currentLang on initialization', () => {
+    spyOn(languageService, 'getCurrentLang').and.returnValue(lang);
+
+    expect(Object.keys(operatorsService.currentLang)).toEqual(
+      Object.keys(lang)
+    );
+  });
+
+  it(
+    'should return Observable on getOperators',
+    fakeAsync(() => {
+      operatorsService.initOperators('en');
+      tick();
+
+      const result = operatorsService.getOperators();
+
+      result.subscribe(data => {
+        expect(data).toBeTruthy();
+      });
+    })
+  );
+});

src/app/core/services/operators.service.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+
+import { Observable } from 'rxjs/Observable';
+import { BehaviorSubject } from 'rxjs/BehaviorSubject';
+
+import { OperatorDoc } from '../../../operator-docs';
+import { LanguageService } from './language.service';
+import { Lang } from '../models/language.model';
+
+@Injectable()
+export class OperatorsService {
+  readonly currentLang: Lang;
+  private _operators = new BehaviorSubject([]);
+  operators = this._operators.asObservable();
+
+  constructor(private languageService: LanguageService) {
+    this.currentLang = this.languageService.getCurrentLang();
+
+    this.initOperators(this.currentLang.code);
+  }
+
+  initOperators(code: string): void {
+    switch (code) {
+      case 'ru':
+        import('../../../i18n/ru').then(module => {
+          this._operators.next(module.ALL_OPERATORS_RU);
+        });
+        break;
+      default:
+        import('../../../operator-docs').then(module => {
+          this._operators.next(module.ALL_OPERATORS_EN);
+        });
+        break;
+    }
+  }
+
+  changeOperatorsLang(lang: Lang): void {
+    this.initOperators(lang.code);
+  }
+
+  getOperators(): Observable<OperatorDoc[]> {
+    return this.operators;
+  }
+}