D-Net

// Work around for https://github.com/angular/angular-cli/issues/7200

const path = require('path');

const webpack = require('webpack');

module.exports = {

  entry: {

    // This is our Express server for Dynamic universal

    server: './server.ts',

    // This is an example of Static prerendering (generative)

    prerender: './prerender.ts'

  },

  target: 'node',

  resolve: { extensions: ['.ts', '.js'] },

  // Make sure we include all node_modules etc

  externals: [/(node_modules|main\..*\.js)/,],

  output: {

    // Puts the output at the root of the dist folder

    path: path.join(__dirname, 'dist'),

    filename: '[name].js'

  },

  module: {

    rules: [

      { test: /\.ts$/, loader: 'ts-loader' }

    ]

  },

  plugins: [

    new webpack.ContextReplacementPlugin(

      // fixes WARNING Critical dependency: the request of a dependency is an expression

      /(.+)?angular(\\|\/)core(.+)?/,

      path.join(__dirname, 'src'), // location of your src

      {} // a map of your routes

    ),

    new webpack.ContextReplacementPlugin(

      // fixes WARNING Critical dependency: the request of a dependency is an expression

      /(.+)?express(\\|\/)(.+)?/,

      path.join(__dirname, 'src'),

      {}

    )

  ]

}

{

  "name": "openaire-connect",

  "version": "1.0.0",

  "license": "Openaire",

  "contributors": [

    "Argiro Kokogiannaki <argirok@di.uoa.gr>",

    "Konstantina Galouni <kgalouni@di.uoa.gr>"

  ],

  "scripts": {

    "ng": "ng",

    "start": " ng serve --disable-host-check --host 0.0.0.0",

    "start:dynamic": "PORT=5000 npm run build:dynamic && npm run serve:dynamic",

    "start:static": "npm run build:static && npm run serve:static",

    "build": "ng build",

    "build:client-and-server-bundles": "ng build --prod -sm --stats-json && ng build --prod --app 1 --output-hashing=false",

    "build:static": "npm run build:client-and-server-bundles && npm run webpack:server && npm run generate:static",

    "build:dynamic": "npm run build:client-and-server-bundles  && npm run webpack:server",

    "generate:static": "cd dist && node prerender",

    "webpack:server": "webpack --config webpack.server.config.js --progress --colors",

    "serve:static": "cd dist/browser && http-server",

    "serve:dynamic": "node dist/server"

  },

  "private": true,

  "dependencies": {

    "@angular/animations": "^4.2.4",

    "@angular/common": "^4.2.4",

    "@angular/compiler": "^4.2.4",

    "@angular/core": "^4.2.4",

    "@angular/forms": "^4.2.4",

    "@angular/http": "^4.2.4",

    "@angular/platform-browser": "^4.2.4",

    "@angular/platform-browser-dynamic": "^4.2.4",

    "@angular/platform-server": "^4.2.4",

    "@angular/router": "^4.2.4",

    "@nguniversal/express-engine": "^1.0.0-beta.3",

    "@nguniversal/module-map-ngfactory-loader": "^1.0.0-beta.3",

    "angular-datatables": "^4.4.0",

    "citation-js": "^0.3.4",

    "clipboard": "^1.5.16",

    "core-js": "^2.4.1",

    "datatables.net": "^1.10.16",

    "datatables.net-dt": "^1.10.16",

    "jquery": "^3.2.1",

    "ngx-json-ld": "0.1.6",

    "rxjs": "^5.4.2",

    "ts-md5": "^1.2.0",

    "wikidata-sdk": "^5.2.9",

    "zone.js": "^0.8.14"

  },

  "devDependencies": {

    "@angular/cli": "^1.3.0",

    "@angular/compiler-cli": "^4.2.4",

    "@angular/language-service": "^4.2.4",

    "@types/datatables.net": "^1.10.8",

    "@types/jquery": "^3.2.17",

    "@types/node": "^8.0.30",

    "cpy-cli": "^1.0.1",

    "http-server": "^0.10.0",

    "reflect-metadata": "^0.1.10",

    "ts-loader": "^2.3.7",

    "typescript": "~2.3.3"

  }

}

{

    "$schema": "./node_modules/@angular/cli/lib/config/schema.json",

    "project": {

      "name": "ng-universal-demo"

    },

    "apps": [

      {

        "root": "src",

        "outDir": "dist/browser",

        "assets": [

          "assets",

          "favicon.ico"

        ],

        "index": "index.html",

        "main": "main.ts",

        "polyfills": "polyfills.ts",

        "test": "test.ts",

        "tsconfig": "tsconfig.app.json",

        "testTsconfig": "tsconfig.spec.json",

        "prefix": "app",

        "styles": [

          "styles.css",

            "../node_modules/datatables.net-dt/css/jquery.dataTables.css"

        ],

        "scripts": [

          "../node_modules/jquery/dist/jquery.js",

          "../node_modules/datatables.net/js/jquery.dataTables.js"

        ],

        "environmentSource": "environments/environment.ts",

        "environments": {

          "dev": "environments/environment.ts",

          "prod": "environments/environment.prod.ts"

        }

      },

      {

        "platform": "server",

        "root": "src",

        "outDir": "dist/server",

        "assets": [

          "assets",

          "favicon.ico"

        ],

        "index": "index.html",

        "main": "main.server.ts",

        "test": "test.ts",

        "tsconfig": "tsconfig.server.json",

        "testTsconfig": "tsconfig.spec.json",

        "prefix": "app",

        "styles": [

          "styles.css"

        ],

        "scripts": [],

        "environmentSource": "environments/environment.ts",

        "environments": {

          "dev": "environments/environment.ts",

          "prod": "environments/environment.prod.ts"

        }

      }

    ],

    "e2e": {

      "protractor": {

        "config": "./protractor.conf.js"

      }

    },

    "lint": [

      {

        "project": "src/tsconfig.app.json",

        "exclude": "**/node_modules/**"

      },

      {

        "project": "src/tsconfig.spec.json",

        "exclude": "**/node_modules/**"

      },

      {

        "project": "e2e/tsconfig.e2e.json",

        "exclude": "**/node_modules/**"

      }

    ],

    "test": {

      "karma": {

        "config": "./karma.conf.js"

      }

    },

    "defaults": {

      "styleExt": "css",

      "component": {

        "spec": false,

        "inlineStyle": true,

        "inlineTemplate": true

      },

      "directive": {

        "spec": false

      },

      "class": {

        "spec": false

      },

      "guard": {

        "spec": false

      },

      "module": {

        "spec": false

      },

      "pipe": {

        "spec": false

      },

      "service": {

        "spec": false

      }

    }

  }

{

  "compileOnSave": false,

  "compilerOptions": {

    "outDir": "./dist/out-tsc",

    "sourceMap": true,

    "declaration": false,

    "moduleResolution": "node",

    "emitDecoratorMetadata": true,

    "experimentalDecorators": true,

    "target": "es5",

    "typeRoots": [

      "node_modules/@types"

    ],

    "lib": [

      "es2017",

      "dom"

    ]

  }

}

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

import { Http, Response, Headers, RequestOptions } from '@angular/http';

import { Observable } from 'rxjs/Rx';

import {COOKIE} from "../../openaireLibrary/login/utils/helper.class"

@Injectable()

export class InviteService {

  constructor(private http:Http) {

    }

     inviteUsers(url:string, subject:string, body:string, recipients:string[]){

       var email = {"subject":subject, "body":body, recipients: recipients };

       return this.http.post(url+"/email", JSON.stringify(email), this.getAuthOptionsWithBody())

           .map(res => <any> res.json())

           .do(res => {console.log("Response is "+res)});

     }

     public getAuthOptionsWithBody():RequestOptions{

     let headers = new Headers();

     headers.append('Content-Type', 'application/json');

     headers.append('X-XSRF-TOKEN',  COOKIE.getCookie(COOKIE.cookieName_id));

     let options = new RequestOptions({ headers: headers, withCredentials:true  });

       return options;

     }

}

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

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

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

import { EnvProperties} from '../../openaireLibrary/utils/properties/env-properties';

import {InviteService} from './invite.service';

import {Session} from '../../openaireLibrary/login/utils/helper.class';

@Component({

    selector: 'invite',

    template: `

    <form class="uk-form-stacked">

        <div>

            <label class="uk-form-label">Subject</label>

            <input type="text" placeholder="Subject" [(ngModel)]=subject name="subject">

        </div>

        <div>

            <div class="uk-form-label">Message</div>

            <textarea cols="" rows="6" placeholder="Email message..." [(ngModel)]=body name="body"></textarea>

         </div>

        <a class="uk-button uk-button-primary" (click)="invite()"> Invite</a>

    </form>

    `

})

export class InviteComponent {

  @Input() communityName:boolean;

  @Input() communityId:string;

  properties:EnvProperties;

  subject:string;

  body:string;

  recipients:string[] = [];

  constructor (private route: ActivatedRoute,

      private _inviteService: InviteService

    ) {

    }

    public ngOnInit() {

      this.route.data

          .subscribe((data: { envSpecific: EnvProperties }) => {

             this.properties = data.envSpecific;

             this.subject = "["+this.communityName+"] Invitation to join community";

             this.body = "Dear sir or madame, \n\nWe would like to invite you to join "+this.communityName +

             " OpenAIRE community (beta."+this.communityId+".openaire.eu)";

           });

    }

    invite(){

      var email = Session.getUserEmail();

      //TODO

        this._inviteService.inviteUsers(  this.properties.adminToolsAPIURL,this.subject, this.body, ["argirok@di.uoa.gr"]).subscribe (

          res => {

             console.log(res);

          });

      }

}

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

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

import { RouterModule } from '@angular/router';

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

import { InviteService } from './invite.service';

import {InviteComponent} from './invite.component';

import {AlertModalModule} from '../../openaireLibrary/utils/modal/alertModal.module';

@NgModule({

  imports: [

    CommonModule,   RouterModule, AlertModalModule, FormsModule

  ],

  declarations: [

    InviteComponent

   ],

  providers:[

    InviteService

    ],

  exports: [

    InviteComponent

     ]

})

export class InviteModule { }

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

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

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

import { EnvProperties} from '../../openaireLibrary/utils/properties/env-properties';

import {AlertModal} from '../../openaireLibrary/utils/modal/alert';

import {SubscribeService} from '../../openaireLibrary/utils/subscribe/subscribe.service';

import {Session} from '../../openaireLibrary/login/utils/helper.class';

@Component({

    selector: 'subscribe',

    template: `

    <span *ngIf="subscribed != null && !showNumbers">

      <div *ngIf="!subscribed && showLoginAlert" class="uk-alert-warning uk-animation-slide-bottom" uk-alert=""  >

      <a class="uk-alert-close" uk-close></a>

      <p>Please login first to subscribe</p>

      </div>

      <a *ngIf="!subscribed" class="uk-button uk-button-primary" (click)="subscribe()"> Subscribe</a>

      <a *ngIf="subscribed" class="uk-button uk-button-danger" (click)="confirmOpen()"> Unsubscribe</a>

    </span>

    <span *ngIf="showNumbers && subscribers !=null && subscribers > 0" >

        Members: {{subscribers}}

    </span>

    <modal-alert (alertOutput)="confirmClose($event)">

    </modal-alert>

    `

})

export class SubscribeComponent {

  // @Input() showSubscribe:boolean = true;

  @Input() showNumbers:boolean;

  @Input() communityId:string;

  subscribed:boolean = null;

  properties:EnvProperties;

  subscribers:number= null;

  showLoginAlert:Boolean = false;

  @ViewChild(AlertModal) alert;

  constructor (private route: ActivatedRoute,

      private _subscribeService: SubscribeService

    ) {

    }

    public ngOnInit() {

      this.route.data

          .subscribe((data: { envSpecific: EnvProperties }) => {

             this.properties = data.envSpecific;

             if(!this.showNumbers){

               var email = Session.getUserEmail();

               if(email == null){

                 this.subscribed = false;

               }else{

                 this._subscribeService.isSubscribedToCommunity(this.communityId, email,this.properties.adminToolsAPIURL).subscribe (

                   res => {

                     this.subscribed = res;

                   });

               }

             }else{

               this._subscribeService.getCommunitySubscribers(this.communityId, this.properties.adminToolsAPIURL).subscribe (

                 res => {

                    this.subscribers = (res && res.subscribers && res.subscribers.length )?res.subscribers.length:0;

                 });

             }

           });

    }

    subscribe(){

      var email = Session.getUserEmail();

      if(email == null){

        this.subscribed = false;

         this.showLoginAlert = true;

      }else{

        this.showLoginAlert = false;

        this._subscribeService.subscribeToCommunity(this.communityId, email, this.properties.adminToolsAPIURL).subscribe (

          res => {

             console.log(res);

             if(!this.subscribed){

               this.subscribed = true;

             }

          });

      }

    }

    unsubscribe(){

      var email = Session.getUserEmail();

      if(email == null){

        this.subscribed = false;

      }else{

        //this.properties.adminToolsAPIURL

        this._subscribeService.unSubscribeToCommunity(this.communityId, email,this.properties.adminToolsAPIURL).subscribe (

          res => {

             console.log(res);

             if(this.subscribed){

               this.subscribed = false;

             }

          });

      }

    }

    confirmOpen(){

        this.alert.cancelButton = true;

        this.alert.okButton = true;

        this.alert.alertTitle = "Unsubscribe community ";

        this.alert.message = "Do you want to proceed? ";

        this.alert.okButtonText = "Yes";

        this.alert.cancelButtonText = "No";

        this.alert.open();

      }

      confirmClose(data){

       this.unsubscribe();

     }

}

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

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

import { RouterModule } from '@angular/router';

import { SubscribeService } from '../../openaireLibrary/utils/subscribe/subscribe.service';

import {SubscribeComponent} from './subscribe.component';

import {AlertModalModule} from '../../openaireLibrary/utils/modal/alertModal.module';

@NgModule({

  imports: [

    CommonModule,   RouterModule, AlertModalModule

  ],

  declarations: [

    SubscribeComponent

   ],

  providers:[

    SubscribeService

    ],

  exports: [

    SubscribeComponent

     ]

})

export class SubscribeModule { }

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

import { Http, Response, Headers, RequestOptions } from '@angular/http';

import { Observable } from 'rxjs/Rx';

import {StatisticsDisplay, StatisticsSummary} from "../../openaireLibrary/connect/statistics/statisticsEntities";

@Injectable()

export class StatisticsService {

    constructor(private http:Http) { }

    getCommunityStatistics(apiUrl: string, communityId: string): Observable<StatisticsSummary> {

        let url = `${apiUrl}communities/${communityId}`;

        console.log(`getting statistics summary from: ${url}`);

        return this.http.get(url)

            .map(res => <any>res.json())

            .do(res => {console.log(res)})

            .map(res => res.statistics)

            .do(res => {console.log(res)});

    }

    getCommunityAdminStatisticsChoices(apiUrl: string, communityId: string): Observable<StatisticsDisplay> {

        let url = `${apiUrl}/statistics/${communityId}`;

        console.log(`getting admin choices for statistics from: ${url}`);

        return this.http.get(url)

            .map(stats => <StatisticsDisplay>stats.json())

            .catch(this.handleError);

    }

    private handleError (error: Response) {

        // in a real world app, we may send the error to some remote logging infrastructure

        // instead of just logging it to the console

        console.log(error);

        return Observable.throw(error  || 'Server error');

    }

}

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

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

import { RouterModule } from '@angular/router';

import {CommunityService} from '../../openaireLibrary/connect/community/community.service';

import {ManageComponent} from './manage.component';

import {AlertModalModule} from '../../openaireLibrary/utils/modal/alertModal.module';

@NgModule({

  imports: [

    CommonModule,   RouterModule, AlertModalModule

  ],

  declarations: [

    ManageComponent

   ],

  providers:[

    CommunityService

    ],

  exports: [

    ManageComponent

     ]

})

export class ManageModule { }

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

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

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

import { EnvProperties} from '../../openaireLibrary/utils/properties/env-properties';

import {CommunityService} from '../../openaireLibrary/connect/community/community.service';

import {Session} from '../../openaireLibrary/login/utils/helper.class';

@Component({

    selector: 'manage',

    template: `

      <a *ngIf="isManager" [href]="'https://beta.admin.connect.openaire.eu/dashboard?communityId='+communityId"  class="uk-button uk-button-default uk-margin-left" target="_blank"  >

        <span class="uk-margin-small-right uk-icon" uk-icon="cog"> </span>Manage</a>

    `

})

export class ManageComponent {

   @Input() communityId:string;

  isManager:boolean = false;

  properties:EnvProperties;

    constructor (private route: ActivatedRoute,

      private _communityService: CommunityService

    ) {

    }

    public ngOnInit() {

      this.route.data

          .subscribe((data: { envSpecific: EnvProperties }) => {

             this.properties = data.envSpecific;

             if(Session.isLoggedIn()){

               if(Session.isPortalAdministrator()||Session.isCommunityCurator()){

                 this.isManager = true;

               }else if(Session.isLoggedIn()){

                 var email = Session.getUserEmail();

                 this._communityService.iscommunityManager(this.properties, this.properties.communityAPI+ this.communityId, email).subscribe (

                     res => {

                       this.isManager = res;

                     });

                 }

               }

             });

    }

}

export class PiwikHelper{

  public static siteIDs={

    "connect": 80,

    "dh-ch":81,

    "ee":82,

    "egi":83,

    "elixir-gr":84,

    "fam":85,

    "instruct":86,

    "mes":87,

    "ni":88,

    "oa-pg":89,

    "rda":90,

    "aginfra":93,

    "clarin":100,

    "dariah":103

  }

}

import { Component, Directive, ElementRef, Renderer, ChangeDetectionStrategy, ViewEncapsulation } from '@angular/core';

import {Observable}       from 'rxjs/Observable';

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

import { EnvProperties} from './openaireLibrary/utils/properties/env-properties';

import{MenuItem, RootMenuItem} from './openaireLibrary/sharedComponents/menu';

import { EnvironmentSpecificService} from './openaireLibrary/utils/properties/environment-specific.service';

import {Session} from './openaireLibrary/login/utils/helper.class';

@Component({

  //changeDetection: ChangeDetectionStrategy.Default,

  //encapsulation: ViewEncapsulation.Emulated,

  selector: 'app-root',

  styles: [`

  `],

  template: `

        <navbar *ngIf= "properties  " portal="monitor" [onlyTop]=false    [userMenuItems]=userMenuItems [menuItems]=menuItems logoPath="assets/"

        [(APIUrl)]="properties.adminToolsAPIURL" [(logInUrl)]="properties.loginUrl" [(logOutUrl)]="properties.logoutUrl"  [(cookieDomain)]="properties.cookieDomain"

         ></navbar>

                   <div class="custom-main-content"   >

                      <main>

                       <router-outlet></router-outlet>

                     </main>

                    </div>

          <feedback *ngIf= "isClient && properties" portalName="Connect" [feedbackmail]=properties.feedbackmail></feedback>

          <cookie-law *ngIf= "isClient" position="bottom">

              OpenAIRE uses cookies in order to function properly.<br>

              Cookies are small pieces of data that websites store in your browser to allow us to give you the best browsing experience possible.

              By using the OpenAIRE portal you accept our use of cookies. <a href="//ec.europa.eu/ipg/basics/legal/cookies/index_en.htm" target="_blank"> Read more <span class="uk-icon">

              <svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg" icon="chevron-right" ratio="1"><polyline fill="none" stroke="#000" stroke-width="1.03" points="7 4 13 10 7 16"></polyline></svg>

              </span></a>

          </cookie-law>

           <bottom *ngIf= "isClient" [menuItems]=bottomMenuItems></bottom>

`

})

export class AppComponent {

  isClient:boolean = false;

  userMenuItems:MenuItem[] =[];

  menuItems:RootMenuItem []=[];

  bottomMenuItems:MenuItem[] =[];

  properties:EnvProperties;

  constructor(  private  route: ActivatedRoute, private propertiesService:EnvironmentSpecificService  ) {

   }

   ngOnInit() {

     this.propertiesService.loadEnvironment()

             .then(es => {

                 this.propertiesService.setEnvProperties(es);

                 this.properties = this.propertiesService.envSpecific;

                 this.bottomMenuItems =[

                 new MenuItem("","About","https://beta.openaire.eu/project-factsheets","",false,[],[],{}),

                 new MenuItem("","News - Events","https://beta.openaire.eu/news-events","",false,[],[],{}),

                 new MenuItem("","Blog","https://blogs.openaire.eu/","",false,[],[],{}),

                 new MenuItem("","Contact us","https://beta.openaire.eu/contact-us","",false,[],[],{})

               ];

               this.userMenuItems =[

                  //new MenuItem("","My links","","/myclaims",false,[],["/myclaims"],{})

                ];

                this.menuItems = [

                  {rootItem: new MenuItem("funders","Funders","","/search/find",false,[],["/search/find"],{}),

                    items: [new MenuItem("","Publications","","/search/find/publications",false,["publication"],["/search/find/publications"],{})

                  ]},

                  {

                  rootItem: new MenuItem("ris","Research initiatives","","",false,[],["/participate/deposit-publications","/participate/deposit-datasets"],{}),

                  items: [new MenuItem("","Publications","","/participate/deposit-publications",false,["publication"],["/participate/deposit-publications"],{}),

                  new MenuItem("","Research Data","","/participate/deposit-datasets",false,["dataset"],["/participate/deposit-datasets"],{})]

                  },

                  {

                  rootItem: new MenuItem("link","Link","","/participate/claim",false,[],["/participate/claim"],{}),

                  items: []

                  }

              ];

    //  this.route.queryParams.subscribe(data => {

     //

    //  });

     if (typeof document !== 'undefined') {

       try{

         this.isClient = true;

       }catch (e) {

       }

     }

   }, error => {

     console.log("App couldn't fetch properties");

       console.log(error);

   });

   }

}

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

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

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

import { RouterModule } from '@angular/router';

 import{ReloadModule} from '../openaireLibrary/reload/reload.module';

@NgModule({

  imports: [

    CommonModule, FormsModule, RouterModule, ReloadModule

  ],

  declarations: [

   ],

  providers:[

    ],

  exports: [

     ]

})

export class LibReloadModule { }

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

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

import { RouterModule } from '@angular/router';

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

const MODULES = [

  // Do NOT include UniversalModule, HttpModule, or JsonpModule here

  CommonModule,

  RouterModule,

  FormsModule,

  ReactiveFormsModule

];

const PIPES = [

  // put pipes here

];

const COMPONENTS = [

  // put shared components here

];

@NgModule({

  imports: [

    ...MODULES

  ],

  declarations: [

    ...PIPES,

    ...COMPONENTS

  ],

  exports: [

    ...MODULES,

    ...PIPES,

    ...COMPONENTS

  ]

})

export class SharedModule {

  static forRoot(): ModuleWithProviders {

    return {

      ngModule: SharedModule,

    };

  }

}

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

import { RouterModule } from '@angular/router';

import { OpenaireDepositBySubjectResultComponent } from './depositBySubjectResult.component';

import {FreeGuard} from '../../openaireLibrary/login/freeGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard';

@NgModule({

  imports: [

    RouterModule.forChild([

     	{ path: '', component: OpenaireDepositBySubjectResultComponent, canActivate: [FreeGuard, IsRouteEnabled], data: {

          redirect: '/error' 

        },canDeactivate: [PreviousRouteRecorder]   }

    ])

  ]

})

export class DepositBySubjectResultsRoutingModule { }

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

import { RouterModule } from '@angular/router';

import { OpenaireDepositDatasetsResultComponent } from './depositDatasetsResult.component';

import {FreeGuard} from '../../openaireLibrary/login/freeGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard';

@NgModule({

  imports: [

    RouterModule.forChild([

     	{ path: '', component: OpenaireDepositDatasetsResultComponent, canActivate: [FreeGuard, IsRouteEnabled], data: {

          redirect: '/error' 

        },canDeactivate: [PreviousRouteRecorder]  }

    ])

  ]

})

export class DepositDatasetsResultsRoutingModule { }

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

import {PiwikHelper} from '../../utils/piwikHelper';

import {ConnectHelper} from '../../openaireLibrary/connect/connectHelper';

@Component({

    selector: 'openaire-deposit-datasets-result',

    template: `

        <deposit-datasets-result [piwikSiteId]=piwikSiteId></deposit-datasets-result>

    `

})

export class OpenaireDepositDatasetsResultComponent {

  piwikSiteId = null;

  constructor (  ) {

    var communityId = ConnectHelper.getCommunityFromDomain(document.location.hostname);

    this.piwikSiteId = PiwikHelper.siteIDs[communityId];

  }

}

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

import {PiwikHelper} from '../../utils/piwikHelper';

import {ConnectHelper} from '../../openaireLibrary/connect/connectHelper';

@Component({

    selector: 'openaire-deposit-datasets',

    template: `

    <deposit-datasets [piwikSiteId]=piwikSiteId>

</deposit-datasets>

    `

})

export class OpenaireDepositDatasetsComponent {

  piwikSiteId = null;

  constructor (  ) {

    var communityId = ConnectHelper.getCommunityFromDomain(document.location.hostname);

    this.piwikSiteId = PiwikHelper.siteIDs[communityId];

  }

}

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

import {Observable}       from 'rxjs/Observable';

import {PiwikHelper} from '../../utils/piwikHelper';

import {ConnectHelper} from '../../openaireLibrary/connect/connectHelper';

@Component({

    selector: 'openaire-deposit-by-subject-result',

    template:`<deposit-by-subject-result [piwikSiteId]=piwikSiteId></deposit-by-subject-result>`

})

export class OpenaireDepositBySubjectResultComponent {

  piwikSiteId = null;

  constructor (  ) {

    var communityId = ConnectHelper.getCommunityFromDomain(document.location.hostname);

    this.piwikSiteId = PiwikHelper.siteIDs[communityId];

  }

}

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

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

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

import { OpenaireDepositDatasetsComponent } from './depositDatasets.component';

 import {DepositDatasetsRoutingModule} from './depositDatasets-routing.module';

import {DepositDatasetsModule} from '../../openaireLibrary/deposit/datasets/depositDatasets.module';

import {FreeGuard} from '../../openaireLibrary/login/freeGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard'

@NgModule({

  imports: [

    CommonModule, FormsModule,

    DepositDatasetsModule,

    DepositDatasetsRoutingModule

  ],

  declarations: [

    OpenaireDepositDatasetsComponent

  ],

  exports: [

    OpenaireDepositDatasetsComponent

   ],

  providers:    [FreeGuard,PreviousRouteRecorder, IsRouteEnabled]

})

export class LibDepositDatasetsModule { }

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

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

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

import { OpenaireDepositDatasetsResultComponent } from './depositDatasetsResult.component';

import {DepositDatasetsResultsRoutingModule} from './depositDatasetsResults-routing.module';

import {DepositDatasetsResultsModule} from '../../openaireLibrary/deposit/datasets/depositDatasetsResults.module';

import {FreeGuard} from '../../openaireLibrary/login/freeGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard'

@NgModule({

  imports: [

    CommonModule, FormsModule,

    DepositDatasetsResultsModule,

    DepositDatasetsResultsRoutingModule

  ],

  declarations: [

    OpenaireDepositDatasetsResultComponent,

  ],

  exports: [

    OpenaireDepositDatasetsResultComponent,

   ],

  providers:    [FreeGuard,PreviousRouteRecorder, IsRouteEnabled]

})

export class LibDepositDatasetsResultsModule { }

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

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

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

import { OpenaireDepositBySubjectResultComponent } from './depositBySubjectResult.component';

import {DepositBySubjectResultsRoutingModule} from './depositBySubjectResult-routing.module';

import {DepositBySubjectResultsModule  } from '../../openaireLibrary/deposit/datasets/depositBySubjectResults.module';

import {FreeGuard} from '../../openaireLibrary/login/freeGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard'

@NgModule({

  imports: [

    CommonModule, FormsModule,

    DepositBySubjectResultsModule,

    DepositBySubjectResultsRoutingModule

  ],

  declarations: [

    OpenaireDepositBySubjectResultComponent

  ],

  exports: [

    OpenaireDepositBySubjectResultComponent

   ],

  providers:    [FreeGuard,PreviousRouteRecorder, IsRouteEnabled]

})

export class LibDepositBySubjectResultsModule { }

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

import { RouterModule } from '@angular/router';

import { OpenaireDepositDatasetsComponent } from './depositDatasets.component';

import {FreeGuard} from '../../openaireLibrary/login/freeGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard'

@NgModule({

  imports: [

    RouterModule.forChild([

     	{ path: '', component: OpenaireDepositDatasetsComponent, canActivate: [FreeGuard, IsRouteEnabled], data: {

          redirect: '/error' 

        },canDeactivate: [PreviousRouteRecorder]  }

    ])

  ]

})

export class DepositDatasetsRoutingModule { }

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

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

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

import { OpenaireDepositPublicationsResultComponent } from './depositPublicationsResult.component';

import {DepositPublicationsResultRoutingModule} from './depositPublicationsResult-routing.module';

import {DepositPublicationsResultsModule} from '../../openaireLibrary/deposit/publications/depositPublicationsResults.module';

import {FreeGuard} from '../../openaireLibrary/login/freeGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard'

@NgModule({

  imports: [

    CommonModule, FormsModule,

    DepositPublicationsResultsModule,

    DepositPublicationsResultRoutingModule

  ],

  declarations: [

    OpenaireDepositPublicationsResultComponent

  ],

  exports: [

    OpenaireDepositPublicationsResultComponent

   ],

  providers:    [FreeGuard,PreviousRouteRecorder, IsRouteEnabled]

})

export class LibDepositPublicationsResultsModule { }

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

import { RouterModule } from '@angular/router';

import { OpenaireDepositPublicationsResultComponent } from './depositPublicationsResult.component';

import {FreeGuard} from '../../openaireLibrary/login/freeGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard'

@NgModule({

  imports: [

    RouterModule.forChild([

      { path: '', component: OpenaireDepositPublicationsResultComponent, canActivate: [FreeGuard, IsRouteEnabled], data: {

          redirect: '/error' 

        }, canDeactivate: [PreviousRouteRecorder] }

    ])

  ]

})

export class DepositPublicationsResultRoutingModule { }

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

import { RouterModule } from '@angular/router';

import { OpenaireDepositPublicationsComponent } from './depositPublications.component';

import {FreeGuard} from '../../openaireLibrary/login/freeGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard'

@NgModule({

  imports: [

    RouterModule.forChild([

      { path: '', component: OpenaireDepositPublicationsComponent, canActivate: [FreeGuard, IsRouteEnabled], data: {

          redirect: '/error' 

        }, canDeactivate: [PreviousRouteRecorder]   }

    ])

  ]

})

export class DepositPublicationsRoutingModule { }

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

import {PiwikHelper} from '../../utils/piwikHelper';

import {ConnectHelper} from '../../openaireLibrary/connect/connectHelper';

@Component({

    selector: 'openaire-deposit-publications-result',

    template: `

        <deposit-publications-result [piwikSiteId]=piwikSiteId></deposit-publications-result>

    `

})

export class OpenaireDepositPublicationsResultComponent {

  piwikSiteId = null;

  constructor (  ) {

    var communityId = ConnectHelper.getCommunityFromDomain(document.location.hostname);

    this.piwikSiteId = PiwikHelper.siteIDs[communityId];

  }

}

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

import {PiwikHelper} from '../../utils/piwikHelper';

import {ConnectHelper} from '../../openaireLibrary/connect/connectHelper';

@Component({

    selector: 'openaire-deposit-publications',

    template: `

    <deposit-publications [piwikSiteId]=piwikSiteId></deposit-publications>

    `

})

export class OpenaireDepositPublicationsComponent {

  piwikSiteId = null;

  constructor (  ) {

    var communityId = ConnectHelper.getCommunityFromDomain(document.location.hostname);

    this.piwikSiteId = PiwikHelper.siteIDs[communityId];

  }

 }

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

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

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

import { OpenaireDepositPublicationsComponent } from './depositPublications.component';

import {DepositPublicationsRoutingModule} from './depositPublications-routing.module';

import {DepositPublicationsModule} from '../../openaireLibrary/deposit/publications/depositPublications.module';

import {FreeGuard} from '../../openaireLibrary/login/freeGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard'

@NgModule({

  imports: [

    CommonModule, FormsModule,

    DepositPublicationsModule,

    DepositPublicationsRoutingModule

  ],

  declarations: [

    OpenaireDepositPublicationsComponent

  ],

  exports: [

    OpenaireDepositPublicationsComponent,

   ],

  providers:    [FreeGuard,PreviousRouteRecorder, IsRouteEnabled]

})

export class LibDepositPublicationsModule { }

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

import { SharedModule } from '../../shared/shared.module';

import { OpenaireDirectLinkingComponent } from './directLinking.component';

import{ DirectLinkingModule} from '../../openaireLibrary/claims/directLinking/directLinking.module';

import {DirectLinkingRoutingModule} from './directLinking-routing.module';

import {LoginGuard} from '../../openaireLibrary/login/loginGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard';

import {ConnectSubscriberGuard} from '../../openaireLibrary/connect/communityGuard/connectSubscriber.guard';

import {CommunityService} from '../../openaireLibrary/connect/community/community.service';

@NgModule({

  imports: [

    SharedModule, DirectLinkingModule, DirectLinkingRoutingModule

  ],

  providers:[LoginGuard, PreviousRouteRecorder, IsRouteEnabled, ConnectSubscriberGuard, CommunityService],

  declarations: [

    OpenaireDirectLinkingComponent

  ], exports:[OpenaireDirectLinkingComponent]

})

export class LibDirectLinkingModule { }

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

import { RouterModule } from '@angular/router';

import { OpenaireDirectLinkingComponent } from './directLinking.component';

import {LoginGuard} from '../../openaireLibrary/login/loginGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard';

import {ConnectSubscriberGuard} from '../../openaireLibrary/connect/communityGuard/connectSubscriber.guard';

@NgModule({

  imports: [

    RouterModule.forChild([

      { path: '', component: OpenaireDirectLinkingComponent, canActivate: [IsRouteEnabled, LoginGuard, ConnectSubscriberGuard], data: {

          redirect: '/error'

        }, canDeactivate: [PreviousRouteRecorder]},

    ])

  ]

})

export class DirectLinkingRoutingModule { }

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

@Component({

    selector: 'openaire-directLinking',

    template: `<directLinking></directLinking>`

})

export class OpenaireDirectLinkingComponent {

}

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

// import {Observable}       from 'rxjs/Observable';

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

//

//

//

// @Component({

//     selector: 'my-claims-demo',

//     template: `

//     <div *ngIf="user" class="container">

//       <div class="page-header">

//           <h1> My Claims Demo</h1>

//       </div>

//       <div>

//         <div class=""><a  routerLink="/Linking">Linking</a></div>

//         <div class=""><a  routerLink]="/MyClaims">MyClaims</a></div>

//         <div class=""><a  routerLink="/Claims">Claims Admin</a></div>

//         <p> Extra parameters for claims admin</p>

//         <div class=""><a  href="claims?fetchBy=User&fetchId=amelie.baecker@uni-bielefeld.de">Claims By user</a></div>

//         <div class=""><a  href="claims?fetchBy=Project&fetchId=corda_______::2c37878a0cede85dbbd1081bb9b4a2f8">Claims By project</a></div>

//         <div class=""><a  href="claims?fetchBy=Context&fetchId=egi::country::gr">Claims By context</a></div>

//

// <!--        <p>Orcid

//           <p>N.M.

//           0000-0002-3477-3082

//           </p>

//         </p> -->

//          <div class=""><a href="publication?articleId=od_______908::3a5b2885656a91307156325644e73b92"  >Publication od_______908::3a5b2885656a91307156325644e73b92</a></div>

//          <!--<div class=""><a href="publication?articleId=od_______908::3a5b2885656a91307156325644e73b92"  >Publication od_______908::3a5b2885656a91307156325644e73b92</a></div>

//          <div class=""><a href="publication?articleId=od_______908::3a5b2885656a91307156325644e73b92"  >Publication od_______908::3a5b2885656a91307156325644e73b92</a></div>-->

//        </div>

//     </div>

//

//

//

// `

// //(click)="changeOrderby('target')"

// //od_______908::3a5b2885656a91307156325644e73b92

//

// })

//  export class MyClaimsDemoComponent {

//   constructor ( private _router: Router  ) {

//    }

//   user:string="argirok@di.uoa.gr";

//    ngOnInit() {

//

//   }

//   goToPub(id: number){

//     this._router.navigate( ['Publication', { articleId: id}] );

//   }

// }

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

import { SharedModule } from '../../shared/shared.module';

import {OpenaireLinkingComponent} from './linkingGeneric.component';

import {LinkingRoutingModule} from './linking-routing.module';

import{   LinkingGenericModule} from '../../openaireLibrary/claims/linking/linkingGeneric.module';

import {LoginGuard} from '../../openaireLibrary/login/loginGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard';

import {ConnectSubscriberGuard} from '../../openaireLibrary/connect/communityGuard/connectSubscriber.guard';

import {CommunityService} from '../../openaireLibrary/connect/community/community.service';

@NgModule({

  imports: [

    SharedModule, LinkingRoutingModule, LinkingGenericModule

  ],

  providers:[LoginGuard, PreviousRouteRecorder, IsRouteEnabled, ConnectSubscriberGuard, CommunityService],

  declarations: [

    OpenaireLinkingComponent

   ], exports:[

   OpenaireLinkingComponent ]

})

export class LibLinkingGenericModule { }

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

import { RouterModule } from '@angular/router';

import { OpenaireLinkingComponent } from './linkingGeneric.component';

import {LoginGuard} from '../../openaireLibrary/login/loginGuard.guard';

import {PreviousRouteRecorder} from '../../openaireLibrary/utils/piwik/previousRouteRecorder.guard';

import {IsRouteEnabled} from '../../openaireLibrary/error/isRouteEnabled.guard';

import {ConnectSubscriberGuard} from '../../openaireLibrary/connect/communityGuard/connectSubscriber.guard';

@NgModule({

  imports: [

    RouterModule.forChild([

      { path: '', component: OpenaireLinkingComponent, canActivate: [IsRouteEnabled, LoginGuard, ConnectSubscriberGuard], data: {

          redirect: '/error'

        }, canDeactivate: [PreviousRouteRecorder]},

    ])

  ]

})

export class LinkingRoutingModule { }

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

import {Observable}       from 'rxjs/Observable';

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

import {ConnectHelper} from '../../openaireLibrary/connect/connectHelper';

@Component({

    selector: 'openaire-linking-generic',

    template: `<linking-generic [communityId]=communityId></linking-generic>`

})

export class OpenaireLinkingComponent {

  communityId:string;

  constructor (

      private route: ActivatedRoute,

      private _router: Router

      ) {

        this.route.queryParams.subscribe(

          communityId => {

                this.communityId = communityId['communityId'];

                 if(!this.communityId){

                  this.communityId  = ConnectHelper.getCommunityFromDomain(document.location.hostname);

                 }

              });

      }

}

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

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

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

// //

// import {UtilsModule} from '../utils/utils.module';

// import {ServicesModule} from '../services/services.module';

//

// import { ClaimsService} from '../services/claims.service';

// //main

// import {ClaimComponent} from './claim/claim.component';

// import {ClaimsAdminComponent} from './claims/claimsAdmin.component';

// import {MyClaimsComponent} from './myClaims/myClaims.component';

// import {LinkingHomeComponent} from './linking/linkingHome.component';

// import {LinkingComponent} from './linking/linking.component';

// import { BulkLinkingComponent } from './linking/bulkLinking.component';

//

// import {BulkClaimComponent} from './linking/bulkClaim/bulkClaim.component';

// import {ClaimsComponent} from './claim-utils/claims.component';

//