D-Net

import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';

import { FormBuilder, FormGroup, Validators } from '@angular/forms';

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

         nonRemovableInterface, noServiceMessage } from '../../../domain/shared-messages';

export class RepoFields {

  id: string;

  datasourceType: string;

  datasourceClass: string;

  registeredBy: string;

@Component({

  selector: 'app-repository-interface-form',

  templateUrl: './datasource-new-interface-form.component.html'

})

export class DatasourceNewInterfaceFormComponent implements OnInit {

  loadingMessage: string;

  successMessage: string;

  errorMessage: string;

  @Input() data: any[] = []; // expects an array containing at least 3 of the 4 below fields in this order

  currentRepo: RepoFields;  // a fraction of the Repository class

  @Output() emitDeleteInterface: EventEmitter<number> = new EventEmitter<number>();

  interfaceToExport: RepositoryInterface;

  repoInterfaceForm: FormGroup;

  readonly repoInterfaceFormDef = {

    customValidationSet: [''],

  baseUrlDesc: Description = baseUrlDesc;

  existingValSetDesc: Description = existingValSetDesc;

  customValSetDesc: Description = customValSetDesc;

  compatibilityLevelDesc: Description = compatibilityLevelDesc;

  identifiedBaseUrl: boolean;

  existingCompLevel: string;

  classCodes: string[] = [];

  compClasses: Map<string, string> = new Map<string, string>();

  existingValSet: boolean;

  interfaceInfo: InterfaceInformation;

  constructor(private fb: FormBuilder,

              private valService: ValidatorService,

              private repoService: RepositoryService) {}

  ngOnInit() {

    if (this.data && (this.data.length >= 3)) {

      this.inRegister = this.data[0];

      this.interfaceID = this.data[1];

      this.currentRepo = this.data[2];

      this.repoInterfaceForm = this.fb.group(this.repoInterfaceFormDef);

      this.chooseValSet(true);

      if (this.data[3]) {

        this.currentInterface = this.data[3];

        this.repoInterfaceForm.get('compatibilityLevel').setValue(this.currentInterface.compatibilityOverride);

      this.getInterfaceInfo();

      this.getCompatibilityClasses();

    }

  }

  getInterfaceInfo() {

    this.successMessage = '';

    this.errorMessage = '';

    if (baseurl) {

          this.interfaceInfo = info;

          if (this.interfaceInfo.identified) {

            this.identifiedBaseUrl = true;

            this.errorMessage = invalidCustomBaseUrl;

          if (this.interfaceInfo.sets) {

            this.valsetList = this.interfaceInfo.sets;

        },

        error => {

          console.log(error);

          this.loadingMessage = '';

        },

        () => {

            if ( this.valsetList.some( x => x === this.currentInterface.apiParams['set']) ) {

              this.repoInterfaceForm.get('selectValidationSet').setValue(this.currentInterface.apiParams.find(entry => entry.param === 'set').value);

          }

          this.loadingMessage = '';

          this.repoInterfaceForm.updateValueAndValidity();

          this.checkIfValid();

        }

      );

    }

  }

  getCompatibilityClasses() {

    if (this.mode === null) {

      this.mode = this.currentRepo.datasourceType;

    }

    this.repoService.getCompatibilityClasses(this.mode).subscribe(

        this.compClasses = classes;

        this.classCodes = Object.keys(this.compClasses);

      },

      error => {

        this.errorMessage = noServiceMessage;

        console.log(error);

      },

      () => {

        this.getExistingCompatibilityLevel();

        this.repoInterfaceForm.updateValueAndValidity();

      }

    );

  }

  getExistingCompatibilityLevel() {

    if (this.currentInterface) {

        this.classCodes.some( x => x === this.currentInterface.compatibilityOverride ) ) {

        this.existingCompLevel = this.compClasses[this.currentInterface.compatibilityOverride];

        this.repoInterfaceForm.get('compatibilityLevel').setValue('');

    }

  }

  chooseValSet(fromList: boolean) {

    this.existingValSet = fromList;

    if (this.existingValSet) {

      this.repoInterfaceForm.get('selectValidationSet').enable();

      this.repoInterfaceForm.get('customValidationSet').disable();

    }  else {

      this.repoInterfaceForm.get('selectValidationSet').disable();

      this.repoInterfaceForm.get('customValidationSet').enable();

    }

    this.checkIfValid();

  }

  checkIfCompatibilityLevelWasChosen() {

    return ( (this.repoInterfaceForm.get('compatibilityLevel').value !== '') ||

             (this.existingCompLevel && (this.existingCompLevel !== '')) );

  }

  formIsValid() {

    return (this.repoInterfaceForm.valid &&

            this.identifiedBaseUrl &&

            this.checkIfCompatibilityLevelWasChosen());

  }

  checkIfValid() {

    if (this.formIsValid()) {

      if (this.inRegister) {

        this.successMessage = 'The harvesting settings are valid!';

      }

    } else {

      this.successMessage = '';

      this.interfaceToExport = null;

    }

  }

  saveInterface() {

    this.errorMessage = '';

    this.successMessage = '';

    if (this.formIsValid()) {

      if (this.existingValSet) {

        valset = this.repoInterfaceForm.get('selectValidationSet').value;

      } else {

        valset = this.repoInterfaceForm.get('customValidationSet').value;

      }

      let compLvl = '';

      if (this.repoInterfaceForm.get('compatibilityLevel').value) {

        this.existingCompLevel = this.compClasses[this.repoInterfaceForm.get('compatibilityLevel').value];

        console.log('this.existingCompLevel is', this.existingCompLevel);

        compLvl = this.repoInterfaceForm.get('compatibilityLevel').value;

      } else {

        compLvl = this.existingCompLevel;

      }

        comment = this.repoInterfaceForm.get('comment').value;

      if (this.currentInterface) {

    } else {

      this.interfaceToExport = null;

  }

    if (intrf == null) {

      intrf = new RepositoryInterface();

    }

    this.updateValidationSet(intrf, this.repoInterfaceForm.get(this.existingValSet ? 'selectValidationSet' : 'customValidationSet').value);

    console.log(intrf);

      intrf.compatibility = this.repoInterfaceForm.get('compatibilityLevel').value;

      intrf.compatibility = this.existingCompLevel;

    intrf.typology = this.currentRepo.datasourceClass;

    return intrf;

  }

    let validationSet = intrf.apiParams.find(element => element.param === 'set');

    if (!validationSet) {

      validationSet = new ApiParamDetails('set', value);

      intrf.apiParams.push(validationSet);

    } else {

      validationSet.value = this.repoInterfaceForm.get(this.existingValSet ? 'selectValidationSet' : 'customValidationSet').value;

    }

  }

  addCurrent (baseurl: string, valset: string, compLvl: string, comment: string) {

    console.log('add current');

    currentInterface.baseurl = baseurl;

    currentInterface.compatibilityOverride = compLvl;

    currentInterface.compatibility = compLvl;

      this.addInterface(currentInterface);

    } else {

      this.interfaceToExport = currentInterface;

    }

  }

  addInterface(newInterface: RepositoryInterface) {

    this.loadingMessage = formSubmitting;

    this.repoService.addInterface(this.currentRepo.datasourceType,

                                  this.currentRepo.id,

                                  this.currentRepo.registeredBy,

      addedInterface => {

        console.log(`addInterface responded ${JSON.stringify(addedInterface)}`);

        this.currentInterface = addedInterface;

      },

      error => {

        console.log(error);

        this.loadingMessage = '';

        this.errorMessage = formErrorWasntSaved;

        this.currentInterface = null;

      },

      () => {

        this.loadingMessage = '';

        if (this.currentInterface.id) {

          this.successMessage = formSuccessAddedInterface;

          this.getExistingCompatibilityLevel();

        } else {

          this.errorMessage = formErrorWasntSaved;

        }

      }

    );

  }

    console.log('update current');

    this.updateValidationSet(this.currentInterface, valset);

    this.currentInterface.baseurl = baseurl;

    this.currentInterface.compatibilityOverride = compLvl;

    this.currentInterface.compatibility = compLvl;

    if (!this.inRegister) {

      this.updateInterface();

    } else {

      this.interfaceToExport = this.currentInterface;

    }

  }

  updateInterface() {

    this.loadingMessage = formSubmitting;

    this.repoService.updateInterface(this.currentRepo.id,

                                     this.currentRepo.registeredBy,

      response => {

        console.log(`updateRepository responded ${JSON.stringify(response)}`);

        if (response) {

          this.currentInterface = response;

          this.successMessage = formSuccessUpdatedInterface;

        } else {

          this.errorMessage = formErrorWasntSaved;

        }

      },

      error => {

        console.log(error);

        this.loadingMessage = '';

        this.errorMessage = formErrorWasntSaved;

      },

      () => {

        this.loadingMessage = '';

        this.getExistingCompatibilityLevel();

      }

    );

  }

  removeInterface() {

    this.errorMessage = '';

    this.successMessage = '';

    if (this.interfaceID > 0) {

          res => console.log(`deleteInterface responded: ${JSON.stringify(res)}`),

          er => console.log(er),

          () => this.emitDeleteInterface.emit(this.interfaceID)

        );

      } else {

        this.emitDeleteInterface.emit(this.interfaceID);

      }

    } else {

      this.errorMessage = nonRemovableInterface;

    }

  }

  getInterface() {

    return this.interfaceToExport;

  }

}