D-Net

<div class="uk-grid-margin uk-grid uk-grid-stack" uk-grid="">

  <div class="uk-width-1-1@m uk-first-column">

    <h1 class="uk-h2">Register your datasource</h1>

    <!-- TOP HELP CONTENT -->

    <help-content #topHelperContent [position]="'top'"

                  [ngClass]="topHelperContent.isPresent()?'uk-margin-medium-top uk-margin-medium-bottom':'clear-style'">

    </help-content>

    <div class="uk-container uk-container-large uk-margin-medium-top uk-margin-medium-bottom">

      <div class="uk-grid">

        <!-- LEFT HELP CONTENT -->

        <aside-help-content #leftHelperContent [position]="'left'"

                            [ngClass]="leftHelperContent.isPresent()?'tm-sidebar uk-width-1-4@m uk-first-column':'clear-style'">

        </aside-help-content>

        <!-- MIDDLE -->

        <div class=" uk-width-expand@m">

          <div>

            <div class="uk-margin uk-grid repositoryTypeSelection" uk-grid="">

              <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match uk-first-column">

                <div class="uk-text-center uk-card uk-card-default uk-card-hover uk-scrollspy-inview uk-animation-slide-top-medium" uk-scrollspy-class="">

                  <a [routerLink]="['literature']" [queryParams]="{ step: 'selectDatasource' }" class="el-link uk-position-cover uk-margin-remove-adjacent"></a>

                  <div class="uk-card-media-top">

                    <img class="el-image" src="../../../assets/imgs/Literature_repos_square.png" alt="" style="width: 100%;">

                  </div>

                  <div class="uk-card-body">

                    <h3 class="el-title uk-margin uk-card-title uk-margin-remove-adjacent uk-margin-small-bottom">

                      Make sure your repository is already registered in OpenDOAR, the authoritative directory of institutional and thematic OA repositories.

                    </h3>

                    <div class="el-meta uk-margin uk-text-meta" style="z-index:9999; position:relative;">

                      <a href="http://v2.sherpa.ac.uk/opendoar/" target="_blank">

                        List provided by

                        <br>

                        OpenDOAR<i class="fa fa-external-link" style="margin-left: 3px !important;"></i>

                      </a>

                    </div>

                  </div>

                </div>

              </div>

              <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match">

                <div class="uk-margin uk-text-center uk-card uk-card-default uk-card-hover uk-scrollspy-inview uk-animation-slide-top-medium" uk-scrollspy-class="" data-id="" style="">

                  <a [routerLink]="['data']" [queryParams]="{ step: 'selectDatasource' }" class="el-link uk-position-cover uk-margin-remove-adjacent" href=""></a>

                  <div class="uk-card-media-top">

                    <img class="el-image" src="../../../assets/imgs/Data_repos_sqare.png" alt="" style="width:100%;">

                  </div>

                  <div class="uk-card-body">

                    <h3 class="el-title uk-margin uk-card-title uk-margin-remove-adjacent uk-margin-small-bottom" >

                      Make sure your data repository is registered in Re3Data, the global registry of research data repositories from different academic disciplines.

                    </h3>

                    <div class="el-meta uk-margin uk-text-meta" style="z-index:9999; position:relative;">

                      <a href="http://www.re3data.org" target="_blank">

                        List provided by

                        <br>

                        Re3data<i class="fa fa-external-link" style="margin-left: 3px !important;"></i>

                      </a>

                    </div>

                  </div>

                </div>

              </div>

              <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match">

                <div class="uk-margin uk-text-center uk-card uk-card-default uk-card-hover uk-scrollspy-inview uk-animation-slide-top-medium" uk-scrollspy-class="" data-id="" style="">

                  <a [routerLink]="['journal']" [queryParams]="{ step: 'basicInformation' }" class="el-link uk-position-cover uk-margin-remove-adjacent"></a>

                  <div class="uk-card-media-top">

                    <img class="el-image" src="../../../assets/imgs/OAJournals_square.png" alt="" style="width:100%;">

                  </div>

                  <div class="uk-card-body">

                    <h3 class="el-title uk-margin uk-card-title uk-margin-remove-adjacent uk-margin-small-bottom">

                      Make sure that your Open Access Journal is compatible with the OpenAIRE literature Guidelines.

                    </h3>

                    <div class="el-meta uk-margin uk-text-meta" style="z-index:9999; position:relative;">

                      <a href="https://www.openaire.eu/helpdesk/" target="_blank">

                        For any questions please contact the OpenAIRE helpdesk.

                        <i class="fa fa-external-link" style="margin-left: 3px !important;"></i>

                      </a>

                    </div>

                  </div>

                </div>

              </div>

              <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match">

                <div class="uk-margin uk-text-center uk-card uk-card-default uk-card-hover uk-scrollspy-inview uk-animation-slide-top-medium" uk-scrollspy-class="" data-id="" style="">

                  <a [routerLink]="['aggregator']" [queryParams]="{ step: 'basicInformation' }" class="el-link uk-position-cover uk-margin-remove-adjacent"></a>

                  <div class="uk-card-media-top">

                    <img class="el-image" src="../../../assets/imgs/Icons_Aggregators_square.png" alt="" style="width:100%;">

                  </div>

                  <div class="uk-card-body">

                    <h3 class="el-title uk-margin uk-card-title uk-margin-remove-adjacent uk-margin-small-bottom">

                      Make sure that your publications aggregator is compatible with the OpenAIRE literature Guidelines.

                    </h3>

                    <div class="el-meta uk-margin uk-text-meta" style="z-index:9999; position:relative;">

                      <a href="http://www.openaire.eu/helpdesk/" target="_blank">

                        For any questions please contact the OpenAIRE helpdesk.

                        <i class="fa fa-external-link" style="margin-left: 3px !important;"></i>

                      </a>

                    </div>

                  </div>

                </div>

              </div>

            </div>

            <div class="uk-margin uk-grid repositoryTypeSelection" uk-grid="">

              <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match">

                <div class="uk-margin uk-text-center uk-card uk-card-default uk-card-hover uk-scrollspy-inview uk-animation-slide-top-medium" uk-scrollspy-class="" data-id="" style="">

                  <a class="el-link uk-position-cover uk-margin-remove-adjacent"></a>

                  <div class="uk-card-media-top">

                    <img class="el-image" src="../../../assets/imgs/CRIS_square_grey.png" alt="" style="width:100%;">

                  </div>

                  <div class="uk-card-body">

                    <!--<h3 class="el-title uk-margin uk-card-title uk-margin-remove-adjacent uk-margin-small-bottom" >

                      Make sure your data repository is registered in Re3Data, the global registry of research data repositories from different academic disciplines.

                    </h3>-->

                    <div class="el-meta uk-margin uk-text-meta" style="z-index:9999; position:relative;">

                      <a>

                        Stay tuned

                      </a>

                    </div>

                  </div>

                </div>

              </div>

              <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match">

                <div class="uk-margin uk-text-center uk-card uk-card-default uk-card-hover uk-scrollspy-inview uk-animation-slide-top-medium" uk-scrollspy-class="" data-id="" style="">

                  <a class="el-link uk-position-cover uk-margin-remove-adjacent"></a>

                  <div class="uk-card-media-top">

                    <img class="el-image" src="../../../assets/imgs/Software_repos_square.png" alt="" style="width:100%;">

                  </div>

                  <div class="uk-card-body">

                    <!--<h3 class="el-title uk-margin uk-card-title uk-margin-remove-adjacent uk-margin-small-bottom" >

                      Catch-all repository registration

                    </h3>-->

                    <div class="el-meta uk-margin uk-text-meta" style="z-index:9999; position:relative;">

                      <a>

                        Stay tuned

                      </a>

                    </div>

                  </div>

                </div>

              </div>

              <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match">

                <div class="uk-margin uk-text-center uk-card uk-card-default uk-card-hover uk-scrollspy-inview uk-animation-slide-top-medium" uk-scrollspy-class="" data-id="" style="">

                  <a class="el-link uk-position-cover uk-margin-remove-adjacent"></a>

                  <div class="uk-card-media-top">

                    <img class="el-image" src="../../../assets/imgs/Catch-all_repos_sqare.png" alt="" style="width:100%;">

                  </div>

                  <div class="uk-card-body">

                    <!--<h3 class="el-title uk-margin uk-card-title uk-margin-remove-adjacent uk-margin-small-bottom" >

                      Make sure your data repository is registered in Re3Data, the global registry of research data repositories from different academic disciplines.

                    </h3>-->

                    <div class="el-meta uk-margin uk-text-meta" style="z-index:9999; position:relative;">

                      <a>

                        Stay tuned

                      </a>

                    </div>

                  </div>

                </div>

              </div>

              <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match">

                <div class="uk-margin uk-text-center uk-card uk-card-default uk-card-hover uk-scrollspy-inview uk-animation-slide-top-medium" uk-scrollspy-class="" data-id="" style="">

                  <a class="el-link uk-position-cover uk-margin-remove-adjacent"></a>

                  <div class="uk-card-media-top">

                    <img class="el-image" src="../../../assets/imgs/Other_Sources_square.png" alt="" style="width:100%;">

                  </div>

                  <div class="uk-card-body uk-text-meta">

                    <!--<h3 class="el-title uk-margin uk-card-title uk-margin-remove-adjacent uk-margin-small-bottom" >

                      Catch-all repository registration

                    </h3>-->

                    <div class="el-meta uk-margin uk-text-meta" style="z-index:9999; position:relative;">

                      <a>

                        Stay tuned

                      </a>

                    </div>

                  </div>

                </div>

              </div>

            </div>

          </div>

        </div>

        <!-- RIGHT HELP CONTENT -->

        <aside-help-content #rightHelperContent [position]="'right'"

                            [ngClass]="rightHelperContent.isPresent()?'tm-sidebar uk-width-1-4@m uk-first-column':'clear-style'">

        </aside-help-content>

      </div>

    </div>

    <!-- BOTTOM HELP CONTENT -->

    <help-content #bottomHelperContent [position]="'bottom'"

                  [ngClass]="bottomHelperContent.isPresent()?'uk-margin-medium-top uk-margin-medium-bottom':'clear-style'">

    </help-content>

  </div>

</div>

/*

*  created by myrto

*/

import { NgModule } from '@angular/core';

import { SourcesRouting } from './sources.routing';

import { SourcesComponent } from './sources.component';

import { SourcesRegisterComponent } from './sources-register.component';

import { CommonModule } from '@angular/common';

import { TabsModule } from 'ngx-bootstrap';

import { SourcesUpdateComponent } from './sources-update.component';

import { SrLiteratureComponent } from './sources-register/sr-literature.component';

import { ReusableComponentsModule } from '../../shared/reusablecomponents/reusable-components.module';

import { SourcesUpdateRepoComponent } from './sources-update-repo.component';

import { FormsModule, ReactiveFormsModule } from '@angular/forms';

import { RepoFilter } from './sourcesPipes';

import { DatasourceInterfaceFormComponent } from './sources-forms/datasource-interface-form.component';

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

import { SrDataComponent } from './sources-register/sr-data.component';

import { RegisterDatasourceSelectExistingComponent } from './sources-register/register-datasource-select-existing.component';

import { DatasourceUpdateFormComponent } from './sources-forms/datasource-update-form.component';

import { SrJournalComponent } from './sources-register/sr-journal.component';

import { SrAggregatorComponent } from './sources-register/sr-aggregator.component';

import { DatasourceCreateFormComponent } from './sources-forms/datasource-create-form.component';

import { RegisterNewDatasourceComponent } from './sources-register/register-new-datasource.component';

import { RegisterExistingDatasourceComponent } from './sources-register/register-existing-datasource.component';

@NgModule ({

  imports: [

    CommonModule,

    TabsModule.forRoot(),

    FormsModule,

    ReactiveFormsModule,

    SourcesRouting,

    ReusableComponentsModule

  ],

  entryComponents : [

    DatasourceInterfaceFormComponent

  ],

  declarations: [

    SourcesComponent,

    SourcesRegisterComponent,

    SourcesUpdateComponent,

    RegisterNewDatasourceComponent,

    RegisterExistingDatasourceComponent,

    SrLiteratureComponent,

    SrDataComponent,

    SrJournalComponent,

    SrAggregatorComponent,

    SourcesUpdateRepoComponent,

    RegisterDatasourceSelectExistingComponent,

    DatasourceUpdateFormComponent,

    DatasourceCreateFormComponent,

    DatasourceInterfaceFormComponent,

    DatasourceNewInterfaceFormComponent,

    RepoFilter                           // a pipe that searches for string in repository name

  ]

})

export class SourcesModule {}

import { Component, Injector, OnDestroy, OnInit } from '@angular/core';

import { MyGroup } from '../../../shared/reusablecomponents/forms/my-group.interface';

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

import { formErrorRequiredFields, formErrorWasntSaved, formInfoLoading, formSubmitting, formSuccessAddedInterface,

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

import { ValidatorService } from '../../../services/validator.service';

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

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

import { baseUrlDesc, compatibilityLevelDesc, customValSetDesc, Description, existingValSetDesc } from '../../../domain/oa-description';

@Component ({

  selector: 'datasource-interface-form',

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

})

export class DatasourceInterfaceFormComponent extends MyGroup implements OnDestroy, OnInit {

  loadingMessage: string;

  successMessage: string;

  errorMessage: string;

  currentRepository: Repository;

  oldInterface: boolean;

  identifiedBaseUrl: boolean;

  existingValSet: boolean;

  interfaceInfo: InterfaceInformation;

  currentInterface: RepositoryInterface;

  valsetList: string[] = [];

  existingCompLevel: string;

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

  classCodes: string[] = [];

  readonly groupDefinition = {

    baseUrl: ['', Validators.required],

    selectValidationSet: [''],

    customValidationSet: [''],

    compatibilityLevel: ['']

  };

  baseUrlDesc: Description = baseUrlDesc;

  existingValSetDesc: Description = existingValSetDesc;

  customValSetDesc: Description = customValSetDesc;

  compatibilityLevelDesc: Description = compatibilityLevelDesc;

  constructor(injector: Injector,

              private valService: ValidatorService,

              private repoService: RepositoryService){

    super(injector);

  }

  ngOnInit() {

    this.currentRepository = <Repository>this.otherData;

    console.log(`other data is: ${JSON.stringify(this.otherData, null, 2)}`);

    if (this.data && this.data.length) {

      this.currentInterface = this.data[0];

      this.patchData.next({

        baseUrl: this.data[0].baseUrl,

        selectValidationSet: '',

        customValidationSet: '',

        compatibilityLevel: this.data[0].desiredCompatibilityLevel

      });

      this.getInterfaceInfo(this.data[0].baseUrl);

      this.data.splice(0, 1);

      this.oldInterface = true;

      console.log(`received an interface!`);

      /*if (this.interfaceInfo && this.interfaceInfo.identified &&

          this.currentInterface.desiredCompatibilityLevel) {

        this.wasSaved = true;

      }*/

    }

    /* initializes MyGroup parent component and the FormGroup */

    super.ngOnInit();

    console.log(this.group, this.parentGroup);

    this.getCompatibilityClasses();

    /*  NOT ANYMORE

    if (this.currentInterface) {

      this.getMyControl('baseUrl').disable();

    }

*/

    this.existingValSet = true;

    this.getMyControl('customValidationSet').disable();

  }

  chooseValSet(existingValSet: boolean) {

    if (existingValSet) {

      this.existingValSet = true;

      this.getMyControl('selectValidationSet').enable();

      this.getMyControl('customValidationSet').disable();

    }  else {

      this.existingValSet = false;

      this.getMyControl('selectValidationSet').disable();

      this.getMyControl('customValidationSet').enable();

    }

    this.checkIfValid();

  }

  getInterfaceInfo(baseUrl: string) {

    this.successMessage = '';

    this.errorMessage = '';

    this.groupErrorMessage = '';

    if (baseUrl) {

      this.loadingMessage = formInfoLoading;

      this.valService.getInterfaceInformation(baseUrl).subscribe(

        info => {

          this.interfaceInfo = info;

          if (this.interfaceInfo.identified) {

            this.identifiedBaseUrl = true;

          } else {

            this.errorMessage = invalidCustomBaseUrl;

          }

          if (this.interfaceInfo.sets) {

            this.valsetList = this.interfaceInfo.sets;

            console.log(this.valsetList);

          }

        },

        error => {

          console.log(error);

          this.loadingMessage = '';

          this.identifiedBaseUrl = false;

          this.errorMessage = noServiceMessage;

        },

        () => {

          if (this.interfaceInfo && this.interfaceInfo.identified &&

              this.currentInterface && this.currentInterface.desiredCompatibilityLevel) {

            this.wasSaved = true;

          }

          if ( this.currentInterface && this.currentInterface.accessParams && this.currentInterface.accessParams['set'] ) {

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

              this.patchData.next({selectValidationSet: this.currentInterface.accessParams['set']});

            } else {

              this.patchData.next({customValidationSet: this.currentInterface.accessParams['set']});

              this.getMyControl('selectValidationSet').enable();

              this.getMyControl('customValidationSet').disable();

            }

          }

          this.loadingMessage = '';

        }

      );

    }

  }

  getCompatibilityClasses() {

    this.repoService.getCompatibilityClasses(this.currentRepository.datasourceType).subscribe(

      classes => {

        this.compClasses = classes;

        for (const key in this.compClasses) {

          this.classCodes.push(key);

        }

      },

      error => {

        this.errorMessage = noServiceMessage;

        console.log(error);

      },

      () => {

        if (this.currentInterface) {

          console.log(`accessParams is ${JSON.stringify(this.currentInterface.accessParams)}`);

          if ( !this.currentInterface.desiredCompatibilityLevel ||

               !this.classCodes.some( x => x === this.currentInterface.desiredCompatibilityLevel ) ) {

            this.patchData.next({compatibilityLevel: ''});

            this.existingCompLevel = this.currentInterface.desiredCompatibilityLevel;

          } else {

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

          }

          if (this.group.valid ) {

            this.exportedData = this.currentInterface;

          }

        }

      }

    );

  }

  saveInterface() {

    this.groupErrorMessage = '';

    this.errorMessage = '';

    this.successMessage = '';

    // if decided that valset is required add && this.checkIfValsetWasChosen() to the condition

    if (this.group.valid && this.checkIfCompatibilityLevelWasChosen() ) {

      if (this.identifiedBaseUrl) {

        const baseUrl = this.getMyControl('baseUrl').value;

        let valset = '';

        if (this.getMyControl('selectValidationSet').enabled) {

          valset = this.getMyControl('selectValidationSet').value;

        } else {

          valset = this.getMyControl('customValidationSet').value;

        }

        let compLvl = '';

        if (this.getMyControl('compatibilityLevel').value) {

          compLvl = this.getMyControl('compatibilityLevel').value;

        } else {

          compLvl = this.existingCompLevel;

        }

        if (this.currentInterface) {

          this.updateCurrent(baseUrl, valset, compLvl);

        } else {

          this.addCurrent(baseUrl, valset, compLvl);

        }

      } else {

        this.errorMessage = invalidCustomBaseUrl;

      }

    } else {

      this.errorMessage = formErrorRequiredFields;

      this.successMessage = '';

    }

  }

  checkIfValsetWasChosen() {

    return ( ( this.getMyControl('selectValidationSet').enabled &&

               this.getMyControl('selectValidationSet').value !== '' ) ||

             ( this.getMyControl('customValidationSet').enabled &&

               this.getMyControl('customValidationSet').value !== '' ) );

  }

  checkIfCompatibilityLevelWasChosen() {

    return ( (this.getMyControl('compatibilityLevel').value !== '') ||

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

  }

  checkIfValid() {

    if (this.inRegister) {

      // if decided that valset is required add && this.checkIfValsetWasChosen() to the condition

      if ( this.group.valid && this.checkIfCompatibilityLevelWasChosen() ) {

        if ( this.identifiedBaseUrl ) {

          const baseUrl = this.getMyControl('baseUrl').value;

          let valset = '';

          if (this.getMyControl('selectValidationSet').enabled) {

            valset = this.getMyControl('selectValidationSet').value;

          } else {

            valset = this.getMyControl('customValidationSet').value;

          }

          let compLvl = '';

          if (this.getMyControl('compatibilityLevel').value) {

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

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

            compLvl = this.getMyControl('compatibilityLevel').value;

          } else {

            compLvl = this.existingCompLevel;

          }

          if (this.currentInterface) {

            this.updateCurrent(baseUrl, valset, compLvl);

          } else {

            this.addCurrent(baseUrl, valset, compLvl);

          }

        }

      } else {

        this.exportedData = null;

        this.wasSaved = false;

        this.successMessage = '';

      }

    }

  }

  updateCurrent (baseUrl: string, valset: string, compLvl: string) {

    this.successMessage = '';

    this.errorMessage = '';

    this.currentInterface.baseUrl = baseUrl;

    this.currentInterface.accessSet = valset;

    this.currentInterface.accessParams['set'] = valset;

    this.currentInterface.desiredCompatibilityLevel = compLvl;

    this.currentInterface.compliance = compLvl;

    this.currentInterface.typology = this.currentRepository.datasourceClass;

    this.exportedData = this.currentInterface;

    if (!this.inRegister) {

      this.loadingMessage = formSubmitting;

      this.updateInterface();

    } else {

      this.loadingMessage = '';

      this.wasSaved = true;

      this.successMessage = 'The interface will be stored when the registration procedure is completed';

    }

  }

  addCurrent (baseUrl: string, valset: string, compLvl: string) {

    this.errorMessage = '';

    this.successMessage = '';

    this.currentInterface = new RepositoryInterface();

    this.currentInterface.baseUrl = baseUrl;

    this.currentInterface.accessSet = valset;

    this.currentInterface.accessParams = {'set': valset};

    this.currentInterface.desiredCompatibilityLevel = compLvl;

    this.currentInterface.compliance = compLvl;

    this.currentInterface.typology = this.currentRepository.datasourceClass;

    this.exportedData = this.currentInterface;

    if (!this.inRegister) {

      this.loadingMessage = formSubmitting;

      this.addInterface();

    } else {

      this.loadingMessage = '';

      this.wasSaved = true;

      this.successMessage = 'The interface will be stored when the registration procedure is completed';

    }

  }

  addInterface() {

    this.repoService.addInterface(this.currentRepository.datasourceType,

                                  this.currentRepository.id,

                                  this.currentRepository.registeredBy,

                                  this.currentInterface).subscribe(

      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.wasSaved = true;

          if ( !this.currentInterface.desiredCompatibilityLevel ||

               !this.classCodes.some( x => x === this.currentInterface.desiredCompatibilityLevel ) ) {

            this.patchData.next({compatibilityLevel: ''});

            this.existingCompLevel = this.currentInterface.desiredCompatibilityLevel;

          } else {

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

          }

        } else {

          this.errorMessage = formErrorWasntSaved;

        }

      }

    );

  }

  updateInterface() {

    this.repoService.updateInterface(this.currentRepository.id, this.currentRepository.registeredBy, this.currentInterface).subscribe(

      response => {

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

        if (response) {

          this.successMessage = formSuccessUpdatedInterface;

          this.wasSaved = true;

        } else {

          this.errorMessage = formErrorWasntSaved;

        }

      },

      error => {

        console.log(error);

        this.loadingMessage = '';

        this.errorMessage = formErrorWasntSaved;

      },

      () => {

        this.loadingMessage = '';

        if ( !this.currentInterface.desiredCompatibilityLevel ||

             !this.classCodes.some( x => x === this.currentInterface.desiredCompatibilityLevel ) ) {

          this.patchData.next({compatibilityLevel: ''});

          this.existingCompLevel = this.currentInterface.desiredCompatibilityLevel;

        } else {

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

        }

      }

    );

  }

  ngOnDestroy() {

    if (this.currentInterface && this.currentInterface.id && this.toBeDeleted) {

      this.repoService.deleteInterface(this.currentInterface.id, this.currentRepository.registeredBy).subscribe(

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

        error => console.log(error),

        () => console.log(`deleted ${this.currentInterface.id}`)

      );

    } else {

      console.log(`deleting empty interface form`);

    }

  }

}

<div *ngIf="ruleSets" [formGroup]="group" class="form-group">

  <div *ngFor="let set of ruleSets; let set_index = index">

    <label class="btn btn-link" for="ruleSet_{{ set_index }}">

      <input id="ruleSet_{{ set_index }}"

             value="{{ set.id }}"

             formControlName="ruleSet"

             name="ruleSet"

             type="radio"

             (change)="refreshLists()"

             [checked]="set_index == 0">

      <span class="uk-margin-small-left">{{ set.name }}</span>

    </label>

  </div>

  <button class="uk-button uk-button-link" (click)="toggleShowRules()">

    <span *ngIf="showRules">

      <i class="fa fa-angle-up"></i>

      Hide Content and Usage Rules</span>

    <span *ngIf="!showRules">

      <i class="fa fa-angle-down"></i>

      Show Content and Usage Rules</span>

  </button>

  <div *ngIf="showRules" class="uk-grid uk-animation-fade">

    <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match uk-first-column" formArrayName="contentRules">

      <div class="margin10">

        <div class="checkbox selectAll">

          <label>

            <input type="checkbox" [checked]="selectedAllContentRules" (change)="toggleSelectAllContentRules()">

            <span>Select / Deselect All Content Rules</span>

          </label>

        </div>

        <div *ngFor="let content of group.controls['contentRules'].controls; let content_index = index" class="checkbox">

          <div [formGroupName]="content_index">

            <label class="uk-link-muted small" for="contentRules_{{ content_index }}">

              <input id="contentRules_{{ content_index }}"

                     title="{{ currentContentRules[content_index].description }}"

                     formControlName="rule"

                     type="checkbox"

                     (change)="onToggleCheckRule($event,'content')">

              <span class="uk-margin-small-left">{{ currentContentRules[content_index].name }}</span>

            </label>

          </div>

        </div>

      </div>

    </div>

    <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match uk-first-column" formArrayName="usageRules">

      <div class="margin10">

        <div class="checkbox selectAll">

          <label>

            <input type="checkbox" [checked]="selectedAllUsageRules" (change)="toggleSelectAllUsageRules()">

            <span>Select / Deselect All Usage Rules</span>

          </label>

        </div>

        <div *ngFor="let usage of group.controls['usageRules'].controls; let usage_index = index" class="checkbox">

          <div [formGroupName]="usage_index">

            <label class="uk-link-muted small" for="usageRules_{{ usage_index }}">

              <input id="usageRules_{{ usage_index }}"

                     value="{{ currentUsageRules[usage_index].id }}"

                     title="{{ currentUsageRules[usage_index].description }}"

                     formControlName="rule"

                     type="checkbox"

                     (change)="onToggleCheckRule($event,'usage')">

              <span class="uk-margin-small-left">{{ currentUsageRules[usage_index].name }}</span>

            </label>

          </div>

        </div>

      </div>

    </div>

  </div>

</div>

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

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

import { baseUrlDesc, compatibilityLevelDesc, customValSetDesc, Description, existingValSetDesc } from '../../../domain/oa-description';

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

import { ValidatorService } from '../../../services/validator.service';

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

import {

  formErrorWasntSaved,

  formInfoLoading, formSubmitting, formSuccessAddedInterface, formSuccessUpdatedInterface, invalidCustomBaseUrl,

  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

  inRegister: boolean;

  interfaceID: number;     // holds the interface index in the interfaces array as displayed

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

  currentInterface: RepositoryInterface;

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

  interfaceToExport: RepositoryInterface;

  repoInterfaceForm: FormGroup;

  readonly repoInterfaceFormDef = {

    baseUrl: ['', Validators.required],

    selectValidationSet: [''],

    customValidationSet: [''],

    compatibilityLevel: ['']

  };

  baseUrlDesc: Description = baseUrlDesc;

  existingValSetDesc: Description = existingValSetDesc;

  customValSetDesc: Description = customValSetDesc;

  compatibilityLevelDesc: Description = compatibilityLevelDesc;

  identifiedBaseUrl: boolean;

  valsetList: string[] = [];

  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('baseUrl').setValue(this.currentInterface.baseUrl);

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

      }

      this.getInterfaceInfo();

      this.getCompatibilityClasses();

    }

  }

  getInterfaceInfo() {

    this.successMessage = '';

    this.errorMessage = '';

    const  baseUrl = this.repoInterfaceForm.get('baseUrl').value;

    if (baseUrl) {

      this.loadingMessage = formInfoLoading;

      this.valService.getInterfaceInformation(baseUrl).subscribe(

        info => {

          this.interfaceInfo = info;

          if (this.interfaceInfo.identified) {

            this.identifiedBaseUrl = true;

          } else {

            this.errorMessage = invalidCustomBaseUrl;

          }

          if (this.interfaceInfo.sets) {

            this.valsetList = this.interfaceInfo.sets;

            console.log(this.valsetList);

          }

        },

        error => {

          console.log(error);

          this.loadingMessage = '';

          this.identifiedBaseUrl = false;

          this.errorMessage = noServiceMessage;

        },

        () => {

          if ( this.currentInterface && this.currentInterface.accessParams && this.currentInterface.accessParams['set'] ) {

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

              this.repoInterfaceForm.get('selectValidationSet').setValue(this.currentInterface.accessParams['set']);

            } else {

              this.repoInterfaceForm.get('customValidationSet').setValue(this.currentInterface.accessParams['set']);

            }

          }

          this.loadingMessage = '';

          this.repoInterfaceForm.updateValueAndValidity();

          this.checkIfValid();

        }

      );

    }

  }

  getCompatibilityClasses() {

    this.repoService.getCompatibilityClasses(this.currentRepo.datasourceType).subscribe(

      classes => {

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

      if (this.currentInterface.desiredCompatibilityLevel &&

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

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

      } else {

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

        this.existingCompLevel = this.currentInterface.desiredCompatibilityLevel;

      }

    }

  }

  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 interface will be stored when the registration procedure is completed';

        this.saveInterface();

      }

    } else {

      this.successMessage = '';

      this.interfaceToExport = null;

    }

  }

  saveInterface() {

    this.errorMessage = '';

    this.successMessage = '';

    if (this.formIsValid()) {

      const baseUrl = this.repoInterfaceForm.get('baseUrl').value;

      let valset = '';

      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;

      }

      if (this.currentInterface) {

        this.updateCurrent(baseUrl, valset, compLvl);

      } else {

        this.addCurrent(baseUrl, valset, compLvl);

      }

    } else {

      this.interfaceToExport = null;

    }

  }

  addCurrent (baseUrl: string, valset: string, compLvl: string) {

    const currentInterface = new RepositoryInterface();

    currentInterface.baseUrl = baseUrl;

    currentInterface.accessSet = valset;

    currentInterface.accessParams = {'set': valset};

    currentInterface.desiredCompatibilityLevel = compLvl;

    currentInterface.compliance = compLvl;

    currentInterface.typology = this.currentRepo.datasourceClass;

    if (!this.inRegister) {

      this.addInterface(currentInterface);

    } else {

      this.successMessage = 'The interface will be stored when the registration procedure is completed';

      console.log('SAVED !');

      this.interfaceToExport = currentInterface;

    }

  }

  addInterface(newInterface: RepositoryInterface) {

    this.loadingMessage = formSubmitting;

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

                                  this.currentRepo.id,

                                  this.currentRepo.registeredBy,

                                  newInterface).subscribe(

      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;

        }

      }

    );

  }

  updateCurrent (baseUrl: string, valset: string, compLvl: string) {

    this.currentInterface.baseUrl = baseUrl;

    this.currentInterface.accessSet = valset;

    this.currentInterface.accessParams['set'] = valset;

    this.currentInterface.desiredCompatibilityLevel = compLvl;

    this.currentInterface.compliance = compLvl;

    this.currentInterface.typology = this.currentRepo.datasourceClass;

    if (!this.inRegister) {

      this.updateInterface();

    } else {

      this.successMessage = 'The interface will be stored when the registration procedure is completed';

      console.log('SAVED !');

      this.interfaceToExport = this.currentInterface;

    }

  }

  updateInterface() {

    this.loadingMessage = formSubmitting;

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

                                     this.currentRepo.registeredBy,

                                     this.currentInterface).subscribe(

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

      if (this.currentInterface && (this.currentInterface.id !== null)) {

        this.repoService.deleteInterface(this.currentInterface.id, this.currentRepo.registeredBy).subscribe(

          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;

  }

}

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

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

import { DatasourceInterfaceFormComponent } from './sources-forms/datasource-interface-form.component';

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

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

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

import { Description, interfaceFormDesc, } from '../../domain/oa-description';

import { formInfoLoading, loadingRepoError } from '../../domain/shared-messages';

import { DatasourceUpdateFormComponent } from './sources-forms/datasource-update-form.component';

import { ConfirmationDialogComponent } from '../../shared/reusablecomponents/confirmation-dialog.component';

import { AuthenticationService } from '../../services/authentication.service';

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

@Component ({

  selector: 'sources-update-repo',

  templateUrl: 'sources-update-repo.component.html'

})

export class SourcesUpdateRepoComponent implements OnInit {

  loadingMessage: string;

  errorMessage: string;

  repoId: string;

  logoURL: string;

  repo: Repository;

  repoInterfaces: RepositoryInterface[] = [];

  @ViewChild('datasourceUpdateForm') datasourceUpdateForm: DatasourceUpdateFormComponent;

  group: FormGroup;

  interfaceFormDesc: Description = interfaceFormDesc;

  updateDatasourceInterfaces: Type<any> = DatasourceInterfaceFormComponent;

  @ViewChildren('interfacesArray') interfacesArray: QueryList<DatasourceNewInterfaceFormComponent>;

  dataForInterfaceComp: any[] = [];

  isModalShown: boolean;

  @ViewChild('updateLogoUrlModal')

  public updateLogoUrlModal: ConfirmationDialogComponent;

  constructor ( private fb: FormBuilder,

                private repoService: RepositoryService,

                private authService: AuthenticationService,

                private route: ActivatedRoute,

                private router: Router) { }

  ngOnInit() {

    this.readRepoId();

  }

  readRepoId() {

    this.repoId = this.route.snapshot.paramMap.get('id');

    console.log(`repoId is ${this.repoId}`);

    this.getRepo();

  }

  getRepo() {

    if (this.repoId) {

      this.loadingMessage = formInfoLoading;

      this.repoService.getRepositoryById(this.repoId).subscribe(

        repo => {

          this.repo = repo;

        },

        error => {

          console.log(error);

          this.loadingMessage = '';

          this.errorMessage = loadingRepoError;

        },

        () => {

          if ( this.authService.activateFrontAuthorization && (this.authService.getUserEmail() !== this.repo.registeredBy.trim()) ) {

            this.router.navigateByUrl('/403-forbidden', { skipLocationChange: true });

          } else {

            this.logoURL = this.repo.logoUrl;

            this.getRepoInterfaces();

          }

        }

      );

    }

  }

  getRepoInterfaces() {

    this.group = this.fb.group({});

    this.repoService.getRepositoryInterface(this.repoId).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 for ${this.repoId} is ${this.repoInterfaces.length}`);

      },

      error => {

        console.log(error);

        this.loadingMessage = '';

        this.errorMessage = loadingRepoError;

      },

      () => {

        this.loadingMessage = '';

        this.fillInterfacesForms();

      }

    );

  }

  fillInterfacesForms() {

    this.dataForInterfaceComp = [];

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

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

        this.dataForInterfaceComp.push([

          false, i,

          { id: this.repo.id,

            datasourceType: this.repo.datasourceType,

            datasourceClass: this.repo.datasourceClass,

            registeredBy: this.repo.registeredBy

          },

          this.repoInterfaces[i]

        ]);

      }

    } else {

      this.dataForInterfaceComp.push([

        false, 0,

        { id: this.repo.id,

          datasourceType: this.repo.datasourceType,

          datasourceClass: this.repo.datasourceClass,

          registeredBy: this.repo.registeredBy

        }

      ]);

    }

  }

  addInterfaceToList(intrf?: RepositoryInterface) {

    const curIndex = this.dataForInterfaceComp.length;

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

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

    if (intrf) {

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

    } else {

      this.dataForInterfaceComp.push([false, 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 = [];

    for (const el of this.interfacesArray.toArray()) {

      const intrf = el.getInterface();

      if (intrf) {

        this.repoInterfaces.push(intrf);

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

      }

    }

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

  }

  updateLogoUrl(logoUrl: string) {

    this.updateLogoUrlModal.ids = [logoUrl];

    this.updateLogoUrlModal.showModal();

  }

  updatedLogoUrl(event: any) {

    this.repo.logoUrl = this.logoURL;

    this.datasourceUpdateForm.updateGroup.get('logoUrl').setValue(this.logoURL);

    this.datasourceUpdateForm.updateRepo();

  }

  getNewLogoUrl( event: any ) {

    this.logoURL = event.target.value;

  }

}

import { Pipe, PipeTransform } from '@angular/core';

import { RepositorySnippet } from '../../domain/typeScriptClasses';

@Pipe ({

  name: 'repoFilter'

})

export class RepoFilter implements PipeTransform {

  transform (items: RepositorySnippet[], searchTerm: string): any[] {

    if (!items) { return []; }

    if (!searchTerm) { return items; }

    searchTerm = searchTerm.trim();

    searchTerm = searchTerm.toLowerCase();

    return items.filter(

      repo => {

        return repo.officialname.toLowerCase().includes(searchTerm);

      }

    );

  }

}

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

@Component ({

  selector: 'app-sources-update',

  templateUrl: 'sources-update.component.html'

})

export class SourcesUpdateComponent implements OnInit {

  constructor() {}

  ngOnInit() {}

  downloadLogo() {

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

  }

}

/*

*  created by myrto

*/

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

@Component({

  selector: 'app-sources-register',

  templateUrl: 'sources-register.component.html'

})

export class SourcesRegisterComponent implements OnInit {

  constructor() {

  }

  ngOnInit() {

  }

}

export const environment = {

  production: true,

  API_ENDPOINT: '/uoa-repository-manager-service',

  FAQ_ENDPOINT: '/api',

  FAQ_HOMEPAGE: '/uoa-admin-tools/'

};

// This file can be replaced during build by using the `fileReplacements` array.

// `ng build ---prod` replaces `environment.ts` with `environment.prod.ts`.

// The list of file replacements can be found in `angular.json`.

export const environment = {

  production: false,

  API_ENDPOINT: '/uoa-repository-manager-service',

  FAQ_ENDPOINT: 'http://audrey.athenarc.gr:5555/api',

  FAQ_HOMEPAGE: 'http://audrey.athenarc.gr:5555'

};

/*

 * In development mode, to ignore zone related error stack frames such as

 * `zone.run`, `zoneDelegate.invokeTask` for easier debugging, you can

 * import the following file, but please comment it out in production mode

 * because it will have performance impact when throw error

 */

// import 'zone.js/dist/zone-error';  // Included with Angular CLI.

<div *ngIf="entitiesList" [formGroup]="group">

  <div class="marginBottom20 uk-margin-top">

    <div>

      <label>Cris Entities</label>

    </div>

    <div>

      <div class="margin10" formArrayName="entities">

        <div class="checkbox selectAll">

          <label>

            <input type="checkbox" [checked]="selectedAllEntities" (change)="toggleSelectAllContentRules()">

            <span>Select / Deselect All Entities</span>

          </label>

        </div>

        <div *ngFor="let content of group.controls['entities'].controls; let i = index" class="checkbox">

          <div [formGroupName]="i">

            <label for="entity_{{ i }}">

              <input id="entity_{{ i }}"

                     formControlName="entity"

                     type="checkbox"

                     (change)="onToggleCheckEntity($event)">

              <span class="uk-margin-small-left">{{ entitiesList[i] }}</span>

            </label>

          </div>

        </div>

      </div>

    </div>

  </div>

  <div class="marginBottom20">

    <div>

      <label>Check Referential Integrity</label>

    </div>

    <div class="uk-grid form-inline">

      <div class="uk-width-1-1">

        <label class="btn btn-link" for="yes">

          <input id="yes"

                 name="referentialIntegrity"

                 value="yes"

                 checked

                 type="radio"> <span class="uk-margin-small-left">Yes</span>

        </label>

        <label class="btn btn-link" for="no">

          <input id="no"

                 name="referentialIntegrity"

                 value="no"

                 type="radio"> <span class="uk-margin-small-left">No</span>

        </label>

      </div>

    </div>

  </div>

</div>

/**

 * This file includes polyfills needed by Angular and is loaded before the app.

 * You can add your own extra polyfills to this file.

 *

 * This file is divided into 2 sections: