D-Net

import { Component, OnInit, QueryList, ViewChild, ViewChildren } from '@angular/core';

import { Repository, RepositoryInterface } from '../../../domain/typeScriptClasses';

import { ActivatedRoute, Router } from '@angular/router';

import { FormBuilder } from '@angular/forms';

import { AsideHelpContentComponent, HelpContentComponent } from '../../../shared/reusablecomponents/help-content.component';

import { RepositoryService } from '../../../services/repository.service';

import { DatasourceNewInterfaceFormComponent } from '../../../shared/reusablecomponents/sources-forms/datasource-new-interface-form.component';

import { concatMap } from 'rxjs/operators';

@Component({

  selector: 'app-register-new-datasource',

  templateUrl: './register-new-datasource.component.html'

})

  loadingMessage: string;

  errorMessage: string;

  datasourceType: string;

  repo: Repository = null;

  repoInterfaces: RepositoryInterface[] = [];

  /* queryParams are used to follow the steps without refreshing the page

   * This was needed for Help Service [which sends back info according to the current router.url].

   * The param that is used is 'step' and the values are: 'basicInformation','interfaces','finish'

   * currentStep represents the number of the current step

   */

  currentStep: number;

  dataForInterfaceComp: any[] = [];

  updateTermsForm: DatasourceUpdateTermsFormComponent;

              private route: ActivatedRoute,

              private router: Router,

              private repoService: RepositoryService) {}

  ngOnInit() {

    if (this.datasourceType) {

      // will execute getStep() every time there is a change in query params

      this.route.queryParams.subscribe(

        params => {

          this.getStep();

        }

      );

  }

  getStep() {

    this.currentStep = 1;

    if (this.route.snapshot.queryParamMap.has('step')) {

      const stepName = this.route.snapshot.queryParamMap.get('step');

      if (stepName === 'basicInformation') {

        this.currentStep = 1;

      } else if (stepName === 'interfaces') {

        if (!this.repo) {

          this.currentStep = 2;

        }

          this.router.navigateByUrl(`/sources/register/${this.datasourceType}?step=basicInformation`);

        } else {

          this.currentStep = 3;

        }

      } else if (stepName === 'finish') {

    }

    this.topHelperContent.ngOnInit();

    this.leftHelperContent.ngOnInit();

    this.bottomHelperContent.ngOnInit();

  moveAStep() {

    this.errorMessage = '';

    if (this.currentStep === 1) {

      this.registerDatasource.registerDatasource();

    } else if (this.currentStep === 2) {

      of(this.getInterfaces()).subscribe(

          if (errors > 0) {

            this.errorMessage = errorsInInterfaces;

            window.scrollTo(1, 1);

              this.errorMessage = noInterfacesSaved;

              window.scrollTo(1, 1);

            }

        }

      );

      this.addRepository();

  }

  moveBackAStep() {

    this.errorMessage = '';

    if (this.currentStep === 2) {

      of(this.getInterfaces()).subscribe(

      this.router.navigateByUrl(`/sources/register/${this.datasourceType}?step=interfaces`);

  }

  addInterfaceToList(intrf?: RepositoryInterface) {

    const curIndex = this.dataForInterfaceComp.length;

      datasourceClass: this.repo.eoscDatasourceType, registeredBy: this.repo.registeredby };

      this.dataForInterfaceComp.push([true, curIndex, curRepoInfo, intrf]);

    } else {

      this.dataForInterfaceComp.push([true, curIndex, curRepoInfo]);

    }

  }

  removeInterfaceFromList(i: number) {

    const tempArray = this.dataForInterfaceComp;

    this.dataForInterfaceComp = [];

    tempArray.splice(i, 1);

    this.dataForInterfaceComp = tempArray;

    console.log(JSON.stringify(this.dataForInterfaceComp));

  }

  getInterfaces() {

    this.repoInterfaces = [];

      const intrf = el.getInterface();

      if (intrf) {

        this.repoInterfaces.push(intrf);

        console.log(JSON.stringify(intrf));

        invalidFormsCount = invalidFormsCount + 1;

        const repo_interface = el.getCurrentValues();

        this.repoInterfaces.push(repo_interface);

        console.log(JSON.stringify(repo_interface));

    }

    return invalidFormsCount;

  fillInterfacesForms() {

    this.dataForInterfaceComp = [];

    if (this.repoInterfaces && (this.repoInterfaces.length > 0)) {

      for (let i = 0; i < this.repoInterfaces.length; i++) {

        this.dataForInterfaceComp.push([

          true, i,

          { id: this.repo.id,

          this.repoInterfaces[i]

        ]);

      }

    } else {

      this.dataForInterfaceComp.push([

        true, 0,

        { id: this.repo.id,

      ]);

    }

  }

  getCurrentRepo(repo: Repository) {

    this.repo = repo;

    of (this.fillInterfacesForms()).subscribe(

  }

    console.log('this.repo', this.repo.consentTermsOfUse, this.repo.fullTextDownload);

    console.log('repo', repo.consentTermsOfUse, repo.fullTextDownload);

    this.repo = repo;

  }

    window.open('../../../../assets/imgs/3_0ValidatedLogo.png', '_blank', 'enabledstatus=0,toolbar=0,menubar=0,location=0');

  }

  addRepository() {

      this.loadingMessage = 'Saving changes';

      this.errorMessage = '';

        },

        error => {

          console.log(error);

          this.loadingMessage = '';

        () => {

          this.saveNewInterfaces();

        }

      );

    }

  }

  saveNewInterfaces() {

    if (this.repoInterfaces && (this.repoInterfaces.length > 0)) {

      from(this.repoInterfaces).pipe(

        concatMap(intrf => {

          if (intrf.id) {

        })

      ).subscribe(

        res => console.log('after save interfaces', JSON.stringify(res)),

        er => {

          console.log(er);

          this.loadingMessage = '';

          this.errorMessage = 'Not all changes were saved. Please try again';

        },

        () => {

          this.loadingMessage = '';

          this.repoInterfaces = [];

      );

    }

  }

}