/ - Diff - D-Net - D-Net project tracking tool

     import {NgModule} from "@angular/core";
     import {CommonModule} from "@angular/common";
     import {TabsModule} from "ngx-bootstrap";
     import { ReactiveFormsModule } from '@angular/forms';
     import {CompatibilityComponent} from "./compatibility.component";
     import {CompatibilityValidateComponent} from "./compatibility-validate.component";
     import {CompatibilityRouting} from "./compatibility.routing";
-...
     import { CompatibilityMonitorRepoComponent } from './compatibility-monitor-repo.component';
     import { CompatibilityValidateTypeComponent } from './compatibility-validate-type.component';
     import { CompatibilityValidateStep1Component } from './compatibility-validate-forms/compatibility-validate-step1.component';
     import { FormsModule, ReactiveFormsModule } from '@angular/forms';
     import { CompatibilityValidateStep2Component } from './compatibility-validate-forms/compatibility-validate-step2.component';
     @NgModule ({
       imports: [
-...
         CompatibilityMonitorComponent,
         CompatibilityMonitorRepoComponent,
         CompatibilityValidateTypeComponent,
         CompatibilityValidateStep1Component
         CompatibilityValidateStep1Component,
         CompatibilityValidateStep2Component
+      ]
     })

                 </div>
                 <div *ngIf="showDatasource">
                   <compatibility-validate-step1 #step1ChooseBaseUrl
                                                 [type]="type"
                                                 [baseUrlList]="baseUrlList"></compatibility-validate-step1>
                 </div>
                 <div *ngIf="showGuidelines">
                   <div>
                     Select Guidlines
                   </div>
                   <compatibility-validate-step2 #step2ChooseGuidelines
                                                 [ruleSets]="ruleSets">
                   </compatibility-validate-step2>
                 </div>
                 <div *ngIf="showParameters">
                   <div>

     <div *ngIf="ruleSets" 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 }}" #ruleSet value="{{ set.id }}" name="ruleSet" type="radio" (change)="getCurrentRuleSets(set_index)" [checked]="set_index === 0">
           <span>{{ set.name }}</span>
         </label>
       </div>
       <div class="uk-grid">
         <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match uk-first-column">
           <div *ngFor="let content of currentContentRules; let content_index = index" class="margin10">
             <label class="btn btn-link" for="rule{{ content.id }}">
               <input id="rule{{ content.id }}" value="{{ content.id }}" name="contentRules_{{content_index}}" type="checkbox" (change)="toggleChooseContentRule($event, content_index)" checked>
               <span>{{ content.name }}</span>
             </label>
           </div>
         </div>
         <div class="uk-width-expand@m uk-width-1-2@s uk-grid-item-match uk-first-column">
           <div *ngFor="let usage of currentUsageRules; let usage_index = index" class="margin10">
             <label class="btn btn-link" for="rule{{ usage_index }}">
               <input id="rule{{ usage_index }}" value="{{ usage.id }}" name="usageRules_{{usage_index}}" type="checkbox" (change)="toggleChooseUsageRule(usage_index)" [checked]="true">
               <span>{{ usage.name }}</span>
             </label>
           </div>
         </div>
       </div>
     </div>

       errorMessage: string;
       chosenUrl: string;
       identifiedUrl: boolean;
       @Input() type: string;
       @Input() baseUrlList: string[];
       constructor(private fb: FormBuilder,
-...
+        }
+      }
       identifyUrl() {
         if (this.group.get('customBaseUrl').value) {
           console.log(`looking for ${this.group.get('customBaseUrl').value}`);
           this.valService.identifyRepository(this.group.get('customBaseUrl').value).subscribe(
             res => this.identifiedUrl = res,
             error =>  console.log(error)
           );
+        }
+      }
       submitForm() {
         let response: boolean;
         if (this.group.get('selectBaseUrl').enabled){
           if ( this.group.get('selectBaseUrl').value) {
             this.chosenUrl = this.group.get('selectBaseUrl').value;
             console.log('selected baseUrl!');
             return true;
           } else {
             this.errorMessage = didntChooseBaseUrl;
             return false;
+          }
         } else if (this.group.get('customBaseUrl').enabled) {
           if ( this.group.get('customBaseUrl').value ) {
             console.log(`looking for ${this.group.get('customBaseUrl').value}`);
             this.valService.identifyRepository(this.group.get('customBaseUrl').value).subscribe(
               res => response = res,
               error =>  console.log(error),
               () => {
                 if ( response ) {
                   this.chosenUrl = this.group.get('customBaseUrl').value;
                   console.log('added new baseUrl!');
                 } else {
                   this.errorMessage = invalidCustomBaseUrl;
+                }
+              }
             );
             if (this.identifiedUrl) {
               this.chosenUrl = this.group.get('customBaseUrl').value;
               console.log('added new baseUrl!');
               return true;
             } else {
               this.errorMessage = invalidCustomBaseUrl;
               return false;
+            }
           } else {
             this.errorMessage = didntChooseBaseUrl;
             return false;
+          }
+        }
+      }

     import { Component, Input, OnInit } from '@angular/core';
     import { Rule, RuleSet } from '../../../domain/typeScriptClasses';
     import { FormControl } from '@angular/forms';
     @Component ({
       selector: 'compatibility-validate-step2',
       templateUrl: 'compatibility-validate-step2.component.html'
     })
     export class CompatibilityValidateStep2Component implements OnInit {
       currentContentRules: Rule[] = [];
       currentUsageRules: Rule[] = [];
       @Input() ruleSets: RuleSet[];
       constructor() {}
       ngOnInit() {
         if ( this.ruleSets.length ) {
           this.getCurrentRuleSets(0);
+        }
+      }
       getCurrentRuleSets(index: number){
         let id = this.ruleSets[index].id;
         let current: RuleSet[] = this.ruleSets.filter(
           set => {
             if (set.id = id) {
               return set;
+            }
+          }
         );
         this.currentContentRules = current[index].contentRules;
         this.currentUsageRules = current[index].usageRules;
+      }
       toggleChooseContentRule(e: any, id: number) {
         if(e.target.checked) {
           console.log(this.currentContentRules[id].name);
+        }
+      }
       toggleChooseUsageRule(id: number) {
         console.log(this.currentUsageRules[id].name);
+      }
+    }

modules/uoa-repository-dashboard-gui/trunk/app/pages/compatibility/compatibility-validate-forms/compatibility-validate-step1.component.html
16	16	<span>or enter new</span>
17	17	</label>
18	18	</div>
19		<input id="customBaseUrl" formControlName="customBaseUrl" class="form-control" type="text">
	19	<input id="customBaseUrl" formControlName="customBaseUrl" class="form-control" type="text" (blur)="identifyUrl()">
20	20	</div>

     import { ActivatedRoute } from '@angular/router';
     import { CompatibilityValidateStep1Component } from './compatibility-validate-forms/compatibility-validate-step1.component';
     import { RepositoryService } from '../../services/repository.service';
     import { Repository } from '../../domain/typeScriptClasses';
     import { Repository, RuleSet } from '../../domain/typeScriptClasses';
     import { AuthenticationService } from '../../services/authentication.service';
     import {
       loadingReposMessage, loadingUserRepoInfo, loadingUserRepoInfoEmpty,
       loadingUserRepoInfoError
       loadingReposMessage, loadingRuleSets, loadingRuleSetsError, loadingUserRepoInfo, loadingUserRepoInfoEmpty,
       loadingUserRepoInfoError, noRuleSets
     } from '../../domain/shared-messages';
     import { ValidatorService } from '../../services/validator.service';
     import { CompatibilityValidateStep2Component } from './compatibility-validate-forms/compatibility-validate-step2.component';
     @Component ({
       selector: 'compatibility-validate-literature',
-...
     export class CompatibilityValidateTypeComponent implements OnInit {
       type: string = '';
       showDatasource: boolean;
       showGuidelines: boolean;
       showParameters: boolean;
       showFinish: boolean;
       step2: string = '';
       step3: string = '';
       step4: string = '';
       baseUrlList: string[] = [];
       ruleSets: RuleSet[] = [];
       errorMessage: string;
       loadingMessage: string;
       showSpinner: boolean;
       @ViewChild('step1ChooseBaseUrl') step1ChooseBaseUrl : CompatibilityValidateStep1Component;
       @ViewChild('step2ChooseGuidelines') step2ChooseGuidelines : CompatibilityValidateStep2Component;
       constructor(private route: ActivatedRoute,
                   private authService: AuthenticationService,
                   private repoService: RepositoryService) {}
                   private repoService: RepositoryService,
                   private valService: ValidatorService) {}
       ngOnInit() {
         this.readType();
-...
       moveAStep(){
         if (this.showDatasource) {
           this.step1ChooseBaseUrl.submitForm();
           if (this.step1ChooseBaseUrl.chosenUrl) {
             this.showGuidelines = true;
             this.showDatasource = false;
             this.step2 = 'active';
           if (this.step1ChooseBaseUrl.submitForm()) {
             this.getRuleSetsForType();
+          }
         } else if (this.showGuidelines) {
           this.showParameters = true;
-...
+        }
+      }
       moveBackAStep(){
       moveBackAStep () {
         if (this.showGuidelines) {
           this.showDatasource = true;
           this.showGuidelines = false;
-...
           );
+      }
       getRuleSetsForType() {
         this.showSpinner = true;
         this.loadingMessage = loadingRuleSets;
         this.valService.getRuleSets(this.type)
           .subscribe(
             rules => this.ruleSets = rules,
             error => {
               this.showSpinner = false;
               this.loadingMessage = '';
               this.errorMessage = loadingRuleSetsError;
             },
             () => {
               this.showSpinner = false;
               this.loadingMessage = '';
               this.showDatasource = false;
               this.step2 = 'active';
               if (this.ruleSets.length) {
                 this.showGuidelines = true;
               } else {
                 this.errorMessage = noRuleSets;
+              }
+            }
           );
+      }
+    }

     import { Injectable } from '@angular/core';
     import { Http } from '@angular/http';
     import { Observable } from 'rxjs/Observable';
     import { RuleSet } from '../domain/typeScriptClasses';
     const httpOptions = {
       headers: new HttpHeaders().set('Content-Type', 'application/json')
-...
       constructor(private http: Http) { }
       /* returns array of sets of rules according to mode (literature, data, cris) */
       getRuleSets(mode: string): Observable<RuleSet[]> {
         let url = `${this.apiUrl}/validator/getRuleSets/${mode}`;
         console.log(`knocking on: ${url}`);
         return this.http.get(url)
           .map(res => <RuleSet[]>res.json())
           .catch(this.handleError);
+      }
       /* returns true if there is a repository containing the identifier */
       identifyRepository(identifier: string): Observable<boolean> {
         let url = `${this.apiUrl}/validator/identifyRepository/{url}?url=${identifier}`;
-...
           .catch(this.handleError);
+      }
       /* from omtd project */
       private handleError(error: Response | any) {
         // In a real world app, we might use a remote logging infrastructure

     export const loadingUserRepoInfoError = "Failed to load information on your registered repositories";
     export const loadingUserRepoInfoEmpty = "You have not yet registered any repository";
     /* Loading Repositories Messages */
     export const reposRetrievalError = 'The repositories can not be retrieved at the moment!';
     export const reposRetrievalError = 'The repositories can not be retrieved at the moment';
     export const noRepositoriesFound = 'No Datasources were found';
     export const noRepositoriesRegistered = 'No Datasources are registered under your account';
     export const loadingReposMessage = 'Retrieving repositories ...';
     export const noRepositoryChosenMsg = 'You need to select a repository first!';
     /* Loading Rules Messages */
     export const loadingRuleSets = 'Retrieving sets of rules ...';
     export const loadingRuleSetsError = 'The rule sets can not be retrieved at the moment';
     export const noRuleSets = 'No rule sets were found';
     /* Loading Topics Messages */
     export const loadingTopics = 'Loading topics for your datasource';
     export const loadingTopicsError = 'Failed to load the topics for your datasource';

       name: string;
       offset: number;
+    }
     export class RuleSet {
       contentRules: Rule[];
       contentRulesIds: number[];
       description: string;
       guidelinesAcronym: string;
       id: number;
       name: string;
       shortName: string;
       usageRules: Rule[];
       usageRulesIds: number[];
       visibility: string[];
+    }
     export class CustomProperties {
       properties: RuleSet[];
+    }
     export class Rule {
         configuration: CustomProperties;
         description: string;
         entity_type: string;
         for_cris: boolean;
         id: number;
         job_type: string;
         mandatory: boolean;
         name: string;
         provider_information: string;
         type: string;
         weight: number;
+    }

Project

General

Profile

D-Net

Revision 50504

Added by Myrto Koukouli over 5 years ago