D-Net

/*

*  created by myrto on 19/12/2018

*/

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 { concatMap } from 'rxjs/operators';

import {

  noInterfacesSaved

} from '../../../domain/shared-messages';

@Component({

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

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

})

export class RegisterExistingDatasourceComponent implements OnInit {

  loadingMessage: string;

  errorMessage: string;

  datasourceType: string;

  currentMode: string;

  datasourceId: string;

  repo: Repository;

  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: 'selectDatasource','basicInformation','interfaces','finish'

   * currentStep represents the number of the current step

   */

  currentStep: number;

  dataForInterfaceComp: any[] = [];

  constructor(private fb: FormBuilder,

              private route: ActivatedRoute,

              private router: Router,

              private repoService: RepositoryService) {}

    if (this.datasourceType && this.currentMode) {

      this.route.queryParams.subscribe(

        params => {

          this.getStep();

        }

      );

  }

  getStep() {

    this.currentStep = 0;

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

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

      if (stepName === 'basicInformation') {

        if (!this.datasourceId) {

          this.currentStep = 1;

        }

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

        if (!this.repo) {

          this.currentStep = 2;

        }

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

        this.currentStep = 3;

        /*} else if (stepName === 'termsOfUse') {

          if (!this.interfacesArray) {

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

          } else {

            this.currentStep = 3;

          }

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

          this.currentStep = 4;*/

    }

    this.topHelperContent.ngOnInit();

    this.leftHelperContent.ngOnInit();

    this.bottomHelperContent.ngOnInit();

  moveAStep() {

    if (this.currentStep === 0) {

      if (this.datasourcesByCountry.goToNextStep()) {

        console.log(`got datasource with id ${this.datasourceId}`);

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

      this.registerDatasource.updateRepo();

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

      of(this.getInterfaces()).subscribe(

          if (errors > 0) {

            this.errorMessage = errorsInInterfaces;

            window.scrollTo(1, 1);

              this.registerRepository();

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

              this.errorMessage = noInterfacesSaved;

              window.scrollTo(1, 1);

            }

        }

      );

      // } else if (this.currentStep === 3) {

    //   this.registerRepository();

  }

  moveBackAStep() {

    if (this.currentStep === 1) {

      this.repoInterfaces = [];

      this.repo = null;

      of(this.getInterfaces()).subscribe(

      // } else if (this.currentStep === 3) {

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

  }

  addInterfaceToList(intrf?: RepositoryInterface) {

    console.log('clicked add interface to list');

    const curRepoInfo = { id: this.repo.id, datasourceType: this.repo.datasourceType,

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

    } else {

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

    }

  }

  removeInterfaceFromList(i: number) {

    const tempArray = this.dataForInterfaceComp;

    this.dataForInterfaceComp = [];

      this.interfacesToDelete.push(tempArray[i][3].id);

    }

    this.dataForInterfaceComp = tempArray;

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

  }

  getInterfaces() {

    let invalidFormsCount = 0;

      const intrf = el.getInterface();

      if (intrf) {

          const i = this.repoInterfaces.findIndex( intr => intr.id === intrf.id );

          this.repoInterfaces[i] = intrf;

        } else {

          this.repoInterfaces.push(intrf);

        }

        invalidFormsCount = invalidFormsCount + 1;

        const repo_interface = el.getCurrentValues();

        if (repo_interface.id && this.repoInterfaces.some(intr => intr.id === repo_interface.id)) {

          const i = this.repoInterfaces.findIndex( intr => intr.id === repo_interface.id );

          this.repoInterfaces[i] = repo_interface;

        } else {

          this.repoInterfaces.push(repo_interface);

        }

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

    }

    console.log('new interfaces is ', this.repoInterfaces);

  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,

            datasourceType: this.repo.datasourceType,

          },

          this.repoInterfaces[i]

        ]);

      }

    } else {

      this.dataForInterfaceComp.push([

        true, 0,

        { id: this.repo.id,

          datasourceType: this.repo.datasourceType,

        }

      ]);

    }

  }

  goToStep2(emitted: boolean) {

    if (emitted) {

      this.moveAStep();

    }

  }

  getRepoId(emitedId: string) {

    this.datasourceId = emitedId;

    this.getRepo();

  }

  getRepo() {

    this.loadingMessage = formInfoLoading;

    if (this.datasourceId) {

      this.repoService.getRepositoryById(this.datasourceId).subscribe(

        repo => {

          this.repo = repo;

        },

        error => {

          console.log(error);

          this.loadingMessage = '';

          this.errorMessage = loadingRepoError;

        },

        () => {

          this.loadingMessage = '';

        }

      );

    }

  }

  getUpdatedRepo(repo: Repository) {

    this.repo = repo;

    if (this.repoInterfaces.length === 0) {

      this.getRepoInterfaces();

    } else {

      of(this.fillInterfacesForms()).subscribe(

    }

  }

  getRepoInterfaces() {

    this.loadingMessage = formInterfacesLoading;

    this.errorMessage = '';

    this.repoService.getRepositoryInterface(this.datasourceId).subscribe(

      interfaces => {

        this.repoInterfaces = interfaces.sort( function(a, b) {

          if (a.id < b.id) {

            return -1;

          } else if (a.id > b.id) {

            return 1;

          } else {

            return 0;

          }

        });

        console.log(`the number of interfaces is ${this.repoInterfaces.length}`);

      },

      error => {

          console.log(error);

          this.errorMessage = loadingInterfacesError;

          this.loadingMessage = '';

      () => {

        this.loadingMessage = '';

        of(this.fillInterfacesForms()).subscribe(

      }

    );

  }

  downloadLogo() {

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

  }

      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) {

            if (this.interfacesToDelete.some(id => id === intrf.id)) {

              req = this.repoService.deleteInterface(intrf.id, this.repo.registeredBy);

            } else {

              req = this.repoService.updateInterface(this.repo.id, this.repo.registeredBy, intrf.comments, intrf);

            return req;

            return this.repoService.addInterface(this.repo.datasourceType, this.repo.id, this.repo.registeredBy, intrf.comments, intrf);

        })

      ).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.repo = null;

          this.repoInterfaces = [];

      );

    }

  }

}