D-Net

##ATTENTION

##DON'T run it in svn folder - it *REMOVES* files

##Copy project in another file "deploy-folder"

##cd "deploy-folder"

##run the script

## uncommect from here-->

# cp connect-admin-beta-properties.json  ./src/assets/env-properties.json;

# pico src/app/openaireLibrary/utils/properties/environment-specific.service.ts;

# npm run build;

# rm -rf dist/assets/common-assets/.svn/;

# echo 'Ready!';

# echo 'Now copy dist to the server!'

##<-- to here

##copy "deploy-folder/dist" in demo.openaire.eu

##coppies of previous deployments exist in  "/home/argiro.kokogiannaki/uoa-portal/connect-adminYYYY-MM-DD"

##become nodejs user: "sudo su nodejs -s /bin/bash"

##go to "cd /srv/www/portal-www"

##cp files from "cp -r HOME_PATH/deploy-folder/* ."

MIT License

Copyright (c) 2017 Stefanos Gatsios

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

SOFTWARE.

{

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

  "project": {

    "name": "admin-portal"

  },

  "apps": [

    {

      "root": "src",

      "outDir": "dist",

      "assets": [

        "assets",

        "robots.txt"

      ],

      "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",

        "../node_modules/interactiveminingv3/assets/css/interactive-mining.css",

        "../node_modules/interactiveminingv3/assets/css/animations.css"

      ],

      "scripts": [

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

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

        "../node_modules/interactiveminingv3/assets/js/ResizeSensor.js",

        "../node_modules/interactiveminingv3/assets/js/jquery.sticky-sidebar.js"

      ],

      "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": {}

  }

}

{

  "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"

    ]

  }

}

{

  "rulesDirectory": [

    "node_modules/codelyzer"

  ],

  "rules": {

    "arrow-return-shorthand": true,

    "callable-types": true,

    "class-name": true,

    "comment-format": [

      true,

      "check-space"

    ],

    "curly": true,

    "eofline": true,

    "forin": true,

    "import-blacklist": [

      true,

      "rxjs"

    ],

    "import-spacing": true,

    "indent": [

      true,

      "spaces"

    ],

    "interface-over-type-literal": true,

    "label-position": true,

    "max-line-length": [

      true,

      140

    ],

    "member-access": false,

    "member-ordering": [

      true,

      {

        "order": [

          "static-field",

          "instance-field",

          "static-method",

          "instance-method"

        ]

      }

    ],

    "no-arg": true,

    "no-bitwise": true,

    "no-console": [

      true,

      "debug",

      "info",

      "time",

      "timeEnd",

      "trace"

    ],

    "no-construct": true,

    "no-debugger": true,

    "no-duplicate-super": true,

    "no-empty": false,

    "no-empty-interface": true,

    "no-eval": true,

    "no-inferrable-types": [

      true,

      "ignore-params"

    ],

    "no-misused-new": true,

    "no-non-null-assertion": true,

    "no-shadowed-variable": true,

    "no-string-literal": false,

    "no-string-throw": true,

    "no-switch-case-fall-through": true,

    "no-trailing-whitespace": true,

    "no-unnecessary-initializer": true,

    "no-unused-expression": true,

    "no-use-before-declare": true,

    "no-var-keyword": true,

    "object-literal-sort-keys": false,

    "one-line": [

      true,

      "check-open-brace",

      "check-catch",

      "check-else",

      "check-whitespace"

    ],

    "prefer-const": true,

    "quotemark": [

      true,

      "single"

    ],

    "radix": true,

    "semicolon": [

      true,

      "always"

    ],

    "triple-equals": [

      true,

      "allow-null-check"

    ],

    "typedef-whitespace": [

      true,

      {

        "call-signature": "nospace",

        "index-signature": "nospace",

        "parameter": "nospace",

        "property-declaration": "nospace",

        "variable-declaration": "nospace"

      }

    ],

    "typeof-compare": true,

    "unified-signatures": true,

    "variable-name": false,

    "whitespace": [

      true,

      "check-branch",

      "check-decl",

      "check-operator",

      "check-separator",

      "check-type"

    ],

    "directive-selector": [

      true,

      "attribute",

      "app",

      "camelCase"

    ],

    "component-selector": [

      true,

      "element",

      "app",

      "kebab-case"

    ],

    "use-input-property-decorator": true,

    "use-output-property-decorator": true,

    "use-host-property-decorator": true,

    "no-input-rename": true,

    "no-output-rename": true,

    "use-life-cycle-interface": true,

    "use-pipe-transform-interface": true,

    "component-class-suffix": true,

    "directive-class-suffix": true,

    "no-access-missing-member": true,

    "templates-use-public": true,

    "invoke-injectable": true

  }

}

/**

 * Created by stefania on 3/21/16.

 */

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

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

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

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

@Component({

    selector: 'dashboard',

    templateUrl: 'dashboard.component.html',

})

export class DashboardComponent {

  communityId:string= null;

  communityType = null;

  properties:EnvProperties;

  constructor( private element: ElementRef, private  route: ActivatedRoute,  private _communityService:CommunityService) {}

  ngOnInit() {

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

        this.properties = data.envSpecific;

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

          this.scroll();

          this.communityId = ((data['communityId'])?data['communityId']:data['community']);

          this._communityService.getCommunity(this.properties, this.properties.communityAPI+this.communityId).subscribe (

            community => {

                this.communityType = community.type;

            },

            error => {

              console.error('Server responded: ' + error);

            }

          );

        });

    });

  }

  public scroll() {

    console.info("scroll into view");

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

       this.element.nativeElement.scrollIntoView();

    }

  }

}

/**

 * Created by stefania on 7/13/17.

 */

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

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

import { Observable } from 'rxjs/Rx';

import { Page } from "../domain/page";

import { PageHelpContent } from "../domain/page-help-content";

import { Community } from "../domain/community";

import { Entity } from "../domain/entity";

import { DivId } from "../domain/divId";

import { DivHelpContent } from "../domain/div-help-content";

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

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

import { CustomOptions } from '../openaireLibrary/services/servicesUtils/customOptions.class';

@Injectable()

export class HelpContentService {

    constructor(private http:Http) {

    }

    static removeNulls(obj){

        var isArray = obj instanceof Array;

        for (var k in obj){

            if (obj[k]===null || obj[k]==='') isArray ? obj.splice(k,1) : delete obj[k];

            else if (typeof obj[k]=="object") HelpContentService.removeNulls(obj[k]);

        }

    }

    getDivIdsFull(page_id: string, helpContentUrl:string) {

      if(page_id) {

        return this.http.get(helpContentUrl + 'divFull?&page='+page_id)

            .map(res => <Array<DivId>> res.json())

            .catch(this.handleError);

      } else {

        return this.http.get(helpContentUrl + 'divFull')

            .map(res => <Array<DivId>> res.json())

            .catch(this.handleError);

      }

    }

    updateDivId(divId: DivId, helpContentUrl:string) {

        HelpContentService.removeNulls(divId);

        return this.http.post(helpContentUrl + 'div/update', JSON.stringify(divId), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    getDivId(divId: string, helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'div/'+divId)

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

            .catch(this.handleError);

    }

    getDivIdFull(divId: string, helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'divFull/'+divId)

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

            .catch(this.handleError);

    }

    saveDivId(divId: DivId, helpContentUrl:string) {

        HelpContentService.removeNulls(divId);

        return this.http.post(helpContentUrl + 'div/save', JSON.stringify(divId), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

/*

    getCommunitiesWithDivId(helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'community?div=true')

            .map(res => <Array<Community>> res.json())

            .catch(this.handleError);

    }

*/

    getCommunityPagesWithDivId(community_pid: string, helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'community/'+community_pid+'/pages?div=true')

            .map(res => <Array<Page>> res.json())

            .catch(this.handleError);

    }

    getCommunityDivHelpContents(community_pid: string, helpContentUrl:string) {

      return this.http.get(helpContentUrl + 'divhelpcontent?community='+community_pid)

          .map(res => <Array<DivHelpContent>> res.json())

          .catch(this.handleError);

    }

    getDivHelpContent(id : string, helpContentUrl:string) {

      return this.http.get(helpContentUrl + 'divhelpcontent/' + id)

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

          .catch(this.handleError);

    }

    insertOrUpdateDivHelpContent(divHelpContent: DivHelpContent, helpContentUrl:string) {

        HelpContentService.removeNulls(divHelpContent);

        return this.http.post(helpContentUrl + 'divhelpcontent', JSON.stringify(divHelpContent), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    deleteDivIds(ids : string[], helpContentUrl:string) {

        return this.http.post(helpContentUrl + 'div/delete',JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            .catch(this.handleError);

    }

    deleteDivHelpContents(ids : string[], helpContentUrl:string) {

         return this.http.post(helpContentUrl + 'divhelpcontent/delete',JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            .catch(this.handleError);

    }

    toggleDivHelpContents(ids : string[],status : boolean, helpContentUrl:string) {

        return this.http.post(helpContentUrl + 'divhelpcontent/toggle?status='+ status.toString(), JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            //.map( res => <string[]> res.json())

            .catch(this.handleError);

    }

    getPagesWithDivIds(community_pid: string, helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'div/pages')

            .map(res => <Map<string, Set<string>>> res.json())

            .catch(this.handleError);

    }

    getPages(helpContentUrl:string,pid:string) {

        return this.http.get(helpContentUrl + 'page'+(pid?("?pid="+pid):""))

            .map(res => <Array<Page>> res.json())

            .catch(this.handleError);

    }

    getPage(pageId:string, helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'page/'+pageId)

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

            .catch(this.handleError);

    }

    getCommunities( helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'community')

            .map(res => <Array<Community>> res.json())

            .catch(this.handleError);

    }

    getCommunity(community_pid: string, helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'community/'+community_pid)

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

            .catch(this.handleError);

    }

    getCommunitiesFull( helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'communityFull')

            .map(res => <Array<Community>> res.json())

            .catch(this.handleError);

    }

    getCommunityFull(community_pid: string, helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'communityFull/'+community_pid)

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

            .catch(this.handleError);

    }

    saveCommunity(community: Community, helpContentUrl:string) {

        // let headers = new Headers({'Content-Type': 'application/json'});

        // let options = new RequestOptions({headers: headers});

        HelpContentService.removeNulls(community);

        return this.http.post(helpContentUrl + 'community/save', JSON.stringify(community),CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    updateCommunity(community: Community, helpContentUrl:string) {

        // let headers = new Headers({'Content-Type': 'application/json'});

        // let options = new RequestOptions({headers: headers});

        HelpContentService.removeNulls(community);

        return this.http.post(helpContentUrl + 'community/update', JSON.stringify(community),  CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    deleteCommunities(ids : string[], helpContentUrl:string) {

        // let headers = new Headers({'Content-Type': 'application/json'});

        // let options = new RequestOptions({headers: headers});

        return this.http.post(helpContentUrl + 'community/delete',JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            .catch(this.handleError);

    }

    getCommunityPages(community_pid: string, params: string, helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'community/'+community_pid+'/pages'+params)

            .map(res => <Array<Page>> res.json())

            .catch(this.handleError);

    }

    getEntities(helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'entity')

            .map(res => <Array<Entity>> res.json())

            .catch(this.handleError);

    }

    getCommunityEntities(community_pid: string, helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'community/'+community_pid+'/entities')

            .map(res => <Array<Entity>> res.json())

            .catch(this.handleError);

    }

    saveEntity(entity: Entity, helpContentUrl:string) {

        HelpContentService.removeNulls(entity);

        return this.http.post(helpContentUrl + 'entity/save', JSON.stringify(entity), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    updateEntity(entity: Entity, helpContentUrl:string) {

        HelpContentService.removeNulls(entity);

        return this.http.post(helpContentUrl + 'entity/update', JSON.stringify(entity), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    // toggleEntity(selectedCommunityId: string, id : string,status : boolean) {

    //     let headers = new Headers({'Content-Type': 'application/json'});

    //     let options = new RequestOptions({headers: headers});

    //

    //     return this.http.post(helpContentUrl + 'community/'+selectedCommunityId+'/entity/toggle?status='+ status.toString()+'&entityId='+id.toString(), options)

    //         .catch(this.handleError);

    // }

    toggleEntities(selectedCommunityPid: string, ids : string[],status : boolean, helpContentUrl:string) {

        return this.http.post(helpContentUrl +'community/'+selectedCommunityPid+ '/entity/toggle?status='+ status.toString(), JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            //.map( res => <string[]> res.json())

            .catch(this.handleError);

    }

    deleteEntities(ids : string[], helpContentUrl:string) {

        return this.http.post(helpContentUrl + 'entity/delete',JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            .catch(this.handleError);

    }

    toggleEntityOfPage(pageId: string, entityId : string,status : boolean, helpContentUrl:string) {

        return this.http.post(helpContentUrl + 'page/'+pageId+'/entity/toggle?status='+ status.toString()+'&entityId='+entityId.toString(), CustomOptions.getAuthOptionsWithBody())

            .catch(this.handleError);

    }

    savePage(page: Page, helpContentUrl:string) {

         HelpContentService.removeNulls(page);

        return this.http.post(helpContentUrl + 'page/save', JSON.stringify(page), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    updatePage(page: Page, helpContentUrl:string) {

        HelpContentService.removeNulls(page);

        return this.http.post(helpContentUrl + 'page/update', JSON.stringify(page), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    togglePages(selectedCommunityPid: string, ids : string[],status : boolean, helpContentUrl:string) {

        return this.http.post(helpContentUrl + 'community/'+selectedCommunityPid+'/page/toggle?status='+ status.toString(),JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            .catch(this.handleError);

    }

    deletePages(ids : string[], helpContentUrl:string) {

        return this.http.post(helpContentUrl + 'page/delete',JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            .catch(this.handleError);

    }

    getPageHelpContents(helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'pagehelpcontent')

            .map(res => <Array<PageHelpContent>> res.json())

            .catch(this.handleError);

    }

    getCommunityPageHelpContents(community_pid: string, helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'pagehelpcontent?community='+community_pid)

            .map(res => <Array<PageHelpContent>> res.json())

            .catch(this.handleError);

    }

    getPageHelpContent(id : string, helpContentUrl:string) {

        return this.http.get(helpContentUrl + 'pagehelpcontent/' + id)

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

            .catch(this.handleError);

    }

    savePageHelpContent(pageHelpContent: PageHelpContent, helpContentUrl:string) {

        HelpContentService.removeNulls(pageHelpContent);

        return this.http.post(helpContentUrl + 'pagehelpcontent/save', JSON.stringify(pageHelpContent), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    updatePageHelpContent(pageHelpContent: PageHelpContent, helpContentUrl:string) {

        HelpContentService.removeNulls(pageHelpContent);

        return this.http.post(helpContentUrl + 'pagehelpcontent/update', JSON.stringify(pageHelpContent), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    deletePageHelpContents(ids : string[], helpContentUrl:string) {

          return this.http.post(helpContentUrl + 'pagehelpcontent/delete',JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            .catch(this.handleError);

    }

    togglePageHelpContents(ids : string[],status : boolean, helpContentUrl:string) {

        return this.http.post(helpContentUrl + 'pagehelpcontent/toggle?status='+ status.toString(), JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            //.map( res => <string[]> res.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.error(error);

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

    }

    // getDataProviders() {

    //     return this.http.get('https://beta.services.openaire.eu/search/v2/api/datasources?format=json').map(res => <any> res.json()).map(res => res.results).do(res => {console.log(res)}).catch(this.handleError);

    // }

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

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

        const 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);

    }

    postCommunityAdminStatisticsChoices(apiUrl: string,

                                        communityId: string,

                                        entity: string,

                                        chartsOrNumbers: string,

                                        title: string,

                                        status: boolean,

                                        monitor: boolean): Observable<any> {

        const url = `${apiUrl}statistics/${communityId}/${entity}/${chartsOrNumbers}?status=${status.toString()}&monitor=${monitor.toString()}`;

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

        return this.http.post(url, title, CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

}

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

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

import {Observable}     from 'rxjs/Observable';

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

import { HttpErrorResponse, HttpResponse } from '@angular/common/http';

import { ErrorObservable } from 'rxjs/observable/ErrorObservable';

import { catchError } from 'rxjs/operators';

@Injectable()

export class ManageCommunityContentProvidersService {

  constructor(private http: Http ) {}

  removeContentProvider (properties:EnvProperties, communityId: string, id: string):any {

    let headers = new Headers({'Content-Type': 'application/json', 'accept': 'application/json'});

    let options = new RequestOptions({headers: headers, body: id});

    let url = properties.communityAPI+communityId+"/contentproviders";

    console.info(url);

    return this.http.delete(url, options)

  }

  addContentProvider(properties:EnvProperties, communityId: string, contentProvider: any) {

      let headers = new Headers({'Content-Type': 'application/json'});

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

      let url = properties.communityAPI+communityId+"/contentproviders";

      console.info(url);

      let communityContentProvider = this.convertSearchContentProviderToCommunityContentProvider(contentProvider, communityId);

      console.info(contentProvider);

      console.info(communityContentProvider);

      return this.http.post(url, JSON.stringify(communityContentProvider), options)

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

    }

  convertSearchContentProviderToCommunityContentProvider(contentProvider: any, community: string) : any {

    let communityContentProvider = {

            "communityId": community,

            "officialname": "",

            "name": "",

            "openaireId": ""

    }

    communityContentProvider.officialname = contentProvider.title.name;

    communityContentProvider.name = contentProvider.englishname;

    communityContentProvider.openaireId = contentProvider.id;

    return communityContentProvider;

  }

}

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

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

import {Observable}     from 'rxjs/Observable';

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

import { HttpErrorResponse, HttpResponse } from '@angular/common/http';

import { ErrorObservable } from 'rxjs/observable/ErrorObservable';

import { catchError } from 'rxjs/operators';

@Injectable()

export class ManageCommunityProjectsService {

  constructor(private http: Http ) {}

  removeProject (properties:EnvProperties, communityId: string, id: string):any {

    let headers = new Headers({'Content-Type': 'application/json', 'accept': 'application/json'});

    let options = new RequestOptions({headers: headers, body: id});

    let url = properties.communityAPI+communityId+"/projects";

    console.info(url);

    return this.http.delete(url, options)

  }

  addProject(properties:EnvProperties, communityId: string, project: any) {

      let headers = new Headers({'Content-Type': 'application/json'});

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

      let url = properties.communityAPI+communityId+"/projects";

      console.info(url);

      let communityProject = this.convertSearchProjectToCommunityProject(project, communityId);

      console.info(project);

      console.info(communityProject);

      let testProject: any = {

        "acronym": "test",

        "communityId": "egi",

        "funder": "test",

        "grantId": "test",

        "name": "test",

        "openaireId": "test"

      };

      return this.http.post(url, JSON.stringify(communityProject), options)

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

    }

  convertSearchProjectToCommunityProject(project: any, community: string) : any {

    let communityProject = {

            "acronym": "",

            "communityId": community,

            "funder": "",

            "grantId": "",

            "name": "",

            "openaireId": ""

    }

    communityProject.acronym = project.acronym;

    communityProject.name = project.title.name;

    communityProject.funder = project.funderShortname;

    communityProject.grantId = project.code;

    communityProject.openaireId = project.id;

    return communityProject;

  }

}

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

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

import {Observable}     from 'rxjs/Observable';

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

import { HttpErrorResponse, HttpResponse } from '@angular/common/http';

import { ErrorObservable } from 'rxjs/observable/ErrorObservable';

import { catchError } from 'rxjs/operators';

@Injectable()

export class  ManageZenodoCommunitiesService {

  constructor(private http: Http ) {}

  removeZCommunity (properties:EnvProperties,communityId: string,id: string):any {

    let headers = new Headers({'Content-Type': 'application/json', 'accept': 'application/json'});

    let options = new RequestOptions({headers: headers, body: id});

    let url = properties.communityAPI+communityId+"/zenodocommunities";

    console.info(url);

    return this.http.delete(url, options)

  }

  addZCommunity(properties:EnvProperties, communityId: string,zenodoid: string) {

      let headers = new Headers({'Content-Type': 'application/json'});

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

      let url = properties.communityAPI+communityId+"/zenodocommunities";

      console.info(url);

      var zCommunity: any = {

        "communityId": communityId,

        "zenodoid": zenodoid

      };

       console.info(zCommunity);

      return this.http.post(url, JSON.stringify(zCommunity), options)

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

    }

}

/**

 * Created by stefania on 4/26/17.

 */

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

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

import { Observable } from 'rxjs/Rx';

import { Topic } from './../domain/topic';

import { Question } from './../domain/question';

import { ActiveTopicQuestions } from './../domain/active-topic-questions';

import { CustomOptions } from '../openaireLibrary/services/servicesUtils/customOptions.class';

@Injectable()

export class FAQService {

    constructor (private http: Http) {}

    private _faqsUrl = process.env.API_ENDPOINT;

    static removeNulls(obj){

        var isArray = obj instanceof Array;

        for (var k in obj){

            if (obj[k]===null || obj[k]==='') isArray ? obj.splice(k,1) : delete obj[k];

            else if (typeof obj[k]=="object") FAQService.removeNulls(obj[k]);

        }

    }

    getTopics() {

        return this.http.get(this._faqsUrl + 'topic')

                .map(res => <Array<Topic>> res.json())

                .catch(this.handleError);

    }

    saveTopic(topic: Topic) {

        FAQService.removeNulls(topic);

        return this.http.post(this._faqsUrl + 'topic', JSON.stringify(topic), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    updateTopic(topic: Topic) {

        FAQService.removeNulls(topic);

        return this.http.put(this._faqsUrl + 'topic', JSON.stringify(topic), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    deleteTopics(ids : string[]) {

        return this.http.post(this._faqsUrl + 'topic/delete',JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            .catch(this.handleError);

    }

    orderTopic(ids: string[], order: string) {

        return this.http.post(this._faqsUrl + 'topic/toggle?order='+ order, JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            .map( res => <string[]> res.json())

            .catch(this.handleError);

    }

    getQuestions() {

        return this.http.get(this._faqsUrl + 'question')

            .map(res => <Array<Question>> res.json())

            .catch(this.handleError);

    }

    saveQuestion(question: Question) {

        FAQService.removeNulls(question);

        return this.http.post(this._faqsUrl + 'question', JSON.stringify(question), CustomOptions.getAuthOptionsWithBody())

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

            .catch(this.handleError);

    }

    toggleQuestion(ids : string[],status : boolean) {

        return this.http.post(this._faqsUrl + 'question/toggle?status='+ status.toString(), JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            .map( res => <string[]> res.json())

            .catch(this.handleError);

    }

    deleteQuestion(id : string) {

        return this.http.delete(this._faqsUrl + 'question/' + id)

            .catch(this.handleError);

    }

    deleteQuestions(ids : string[]) {

        return this.http.post(this._faqsUrl + 'question/delete',JSON.stringify(ids), CustomOptions.getAuthOptionsWithBody())

            .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.error(error);

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

    }

}

<navbar *ngIf= "properties"   portal="connect-admin" logoPath="assets/imgs/" [onlyTop]=false [userMenu]=true  [homeurl] = false [userMenuItems]=userMenuItems [menuItems]=menuItems [(logInUrl)]=logInUrl [(logOutUrl)]=logOutUrl [(community)]=community class="adminMenu"></navbar>

<div  id="wrapper" class="uk-section uk-margin-top uk-padding-remove-bottom">

  <div class="uk-grid" uk-height-viewport="expand: true">

    <div *ngIf="communityId && communityId!=''" id="sidebar" class="uk-width-1-5 uk-light sidebar uk-margin-top uk-margin-left">

      <ul class="uk-nav uk-nav-default sidebar">

        <li class="uk-nav-header uk-parent">

          <a routerLink="/dashboard"  [queryParams]="{communityId: this.communityId}" routerLinkActive="active">

              <span><span class="uk-margin-small-right uk-icon" uk-icon="home"></span> Overview</span>

          </a>

        </li>

         <li *ngIf="communityId != 'openaire'" class="uk-nav-header uk-parent">

           <span class="uk-margin-small-right uk-icon" uk-icon="album"></span>

           Community

            <ul class="uk-nav-sub">

              <li *ngIf="isPortalAdministrator">

                  <a routerLink="/communities" routerLinkActive="active" [queryParams]="{communityId: this.communityId}">

                      <span>Communities</span>

                  </a>

              </li>

              <li >

                  <a routerLink="/community-edit-form" routerLinkActive="active" [queryParams]="{communityId: this.communityId}">

                      <span>Community profile</span>

                  </a>

              </li>

            </ul>

         </li>

         <li *ngIf="communityId != 'openaire'" class="uk-nav-header uk-parent">

           <span class="uk-margin-small-right uk-icon" uk-icon="list"></span>

           Community content

            <ul class="uk-nav-sub">

              <li>

                  <a routerLink="/manage-projects" routerLinkActive="active" [queryParams]="{communityId: this.communityId}">

                      <span>Projects</span>

                  </a>

              </li>

              <li>

                  <a routerLink="/manage-content-providers" routerLinkActive="active" [queryParams]="{communityId: this.communityId}">

                      <span>Content providers</span>

                  </a>

              </li>

              <li  *ngIf="communityType && communityType != 'ri'">

                  <a routerLink="/manage-subjects" routerLinkActive="active" [queryParams]="{communityId: this.communityId}">

                      <span>Subjects</span>

                  </a>

              </li>

              <li>

                  <a routerLink="/manage-zenodo-communities" routerLinkActive="active" [queryParams]="{communityId: this.communityId}">

                      <span>Zenodo communities</span>

                  </a>

              </li>

            </ul>

         </li>

         <li *ngIf="isPortalAdministrator" class="uk-nav-header uk-parent">

           Classes for help text

            <ul class="uk-nav-sub">

              <li>

                  <a routerLink="/classes" routerLinkActive="active" [queryParams]="{communityId: this.communityId}">

                      <span>Classes</span>

                  </a>

              </li>

            </ul>

         </li>

         <li class="uk-nav-header uk-parent">

           <span uk-icon="world" class="uk-icon"></span>

           Entities & pages

            <ul class="uk-nav-sub">

              <li>

                  <a routerLink="/entities" routerLinkActive="active" [queryParams]="{communityId: this.communityId}">

                      <span>Activate entities</span>

                  </a>

              </li>

              <li>

                  <a routerLink="/pages" routerLinkActive="active" [routerLinkActiveOptions]="{exact:true}" [queryParams]="{communityId: this.communityId}">

                      <span>Pages</span>

                  </a>

                  <ul class="uk-nav-sub">

                    <li>

                        <a routerLink="/pages" routerLinkActive="active" [queryParams]="{type: 'search', communityId: this.communityId}" [routerLinkActiveOptions]="{exact:true}">

                            <span>Search</span>

                        </a>

                    </li>

                    <li>

                        <a routerLink="/pages" routerLinkActive="active" [queryParams]="{type: 'link', communityId: this.communityId}" [routerLinkActiveOptions]="{exact:true}">

                            <span>Link</span>

                        </a>

                    </li>

                    <li>

                        <a routerLink="/pages" routerLinkActive="active" [queryParams]="{type: 'share', communityId: this.communityId}" [routerLinkActiveOptions]="{exact:true}">

                            <span>Share</span>

                        </a>

                    </li>

                    <li>

                        <a routerLink="/pages" routerLinkActive="active" [queryParams]="{type: 'landing', communityId: this.communityId}" [routerLinkActiveOptions]="{exact:true}">

                            <span>Landing</span>

                        </a>

                    </li>

                    <li>

                        <a routerLink="/pages" routerLinkActive="active" [queryParams]="{type: 'html', communityId: this.communityId}" [routerLinkActiveOptions]="{exact:true}">

                            <span>Html</span>

                        </a>

                    </li>

                    <li>

                        <a routerLink="/pages" routerLinkActive="active" [queryParams]="{type: 'other', communityId: this.communityId}" [routerLinkActiveOptions]="{exact:true}">

                            <span>Other</span>

                        </a>

                    </li>

                  </ul>

              </li>

            </ul>

         </li>

         <li class="uk-nav-header uk-parent">

          <span class="uk-margin-small-right uk-icon" uk-icon="file-edit"></span>

           Help texts

            <ul class="uk-nav-sub">

              <li>

                  <a routerLink="/pageContents" [queryParams]="{communityId: this.communityId}"  routerLinkActive="active">

                      <span>Page help texts</span>

                  </a>

              </li>

              <li>

                  <a routerLink="/classContents" [queryParams]="{communityId: this.communityId}" routerLinkActive="active">

                      <span>Class help texts</span>

                  </a>

              </li>

            </ul>

         </li>

         <li *ngIf="communityId != 'openaire'" class="uk-nav-header uk-parent">

           <a routerLink="/stats"  [queryParams]="{communityId: this.communityId}" routerLinkActive="active">

               <span><span class="uk-margin-small-right uk-icon" uk-icon="image"></span> Statistics & charts</span>

           </a>

         </li>

         <li *ngIf="communityId != 'openaire'" class="uk-nav-header uk-parent">

           <a routerLink="/claims"  [queryParams]="{communityId: this.communityId}" routerLinkActive="active">

               <span><span class="uk-margin-small-right uk-icon" uk-icon="link"></span> Links</span>

           </a>

         </li>

         <li   *ngIf="communityType && communityType == 'ri' && communityId!='openaire'" class="uk-nav-header uk-parent">

           <a routerLink="/mining/manage-profiles"  [queryParams]="{communityId: this.communityId}" routerLinkActive="active">

               <span><span class="uk-margin-small-right uk-icon" uk-icon="settings"></span> Text mining rules</span>

           </a>

         </li>

         <li *ngIf="communityId != 'openaire'" class="uk-nav-header uk-parent">

           <span class="uk-margin-small-right uk-icon" uk-icon="user"></span>

           Users

            <ul class="uk-nav-sub">

              <li>

                  <a routerLink="/manage-subscribers" routerLinkActive="active" [queryParams]="{communityId: this.communityId}">

                      <span>Subscribers</span>

                  </a>

              </li>

              <li>

                  <a  [href]="'https://beta.'+this.communityId+'.openaire.eu/invite'" target="_blank">

                      <span>Invite to subscribe</span>

                  </a>

              </li>

               <li>

                  <a routerLink="/manage-user-notifications" routerLinkActive="active" [queryParams]="{communityId: this.communityId}">

                      <span>Notification settings </span>

                  </a>

              </li>

            </ul>

         </li>

      </ul>

    </div>

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

  <!-- <div class="uk-width-expand"> -->

    <router-outlet></router-outlet>

  </div>

  </div>

</div>

<!--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"></bottom>

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

import { BrowserModule } from '@angular/platform-browser';

import { HttpModule, JsonpModule } from '@angular/http';

import { AppComponent } from "./app.component";

import { routing, appRoutingProviders } from "./app.routing";

import { DashboardComponent } from "./dashboard.component";

import { TopicsComponent } from "./pages/faq/topics.components";

import { QuestionsComponent } from "./pages/faq/questions.component";

import { FAQService } from "./services/faq.service";

import { ModalModule } from 'ngx-bootstrap';

//import { CollapseModule } from 'ngx-bootstrap';

//import { AccordionModule } from 'ngx-bootstrap';

import { TopicsFormComponent } from "./pages/faq/topics-form.component";

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

import { ModalFormComponent } from "./pages/modal-form.component";

import { QuestionsFormComponent } from "./pages/faq/questions-form.component";

import { DeleteConfirmationDialogComponent } from "./pages/delete-confirmation-dialog.component";

//import { DeleteConfirmationDialogModule } from "./pages/delete-confirmation-dialog.module";

// import { JWBootstrapSwitchModule } from 'jw-bootstrap-switch-ng2';

import { PagesComponent } from "./pages/page/pages.component";

import { HelpContentService } from "./services/help-content.service";

import { PageFormComponent } from "./pages/page/page-form.component";

import { PageHelpContentsComponent } from "./pages/helpcontent/page-help-contents.component";

import { NewPageHelpContentComponent } from "./pages/helpcontent/new-page-help-content.component";

import { CKEditorModule } from 'ng2-ckeditor';

import { PageContentFormComponent } from "./pages/helpcontent/page-help-content-form.component";

import { EditPageHelpContentComponent } from "./pages/helpcontent/edit-page-help-content.component";

import { CommunitiesComponent } from './pages/community/communities.component';

import { CommunityFormComponent } from './pages/community/community-form.component';

import { EntitiesComponent } from "./pages/entity/entities.component";

import { EntityFormComponent } from "./pages/entity/entity-form.component";

import { DivIdsComponent } from "./pages/divId/divIds.component";

import { DivIdFormComponent } from "./pages/divId/divId-form.component";

//import { DivIdModule } from './pages/divId/divId.module';

import { DivHelpContentsComponent } from "./pages/divhelpcontent/div-help-contents.component";

import { NewDivHelpContentComponent } from "./pages/divhelpcontent/new-div-help-content.component";

import { DivContentFormComponent } from "./pages/divhelpcontent/div-help-content-form.component";

import { EditDivHelpContentComponent } from "./pages/divhelpcontent/edit-div-help-content.component";

//import { DivHelpContentsModule } from './pages/divhelpcontent/divhelpcontent.module';

import { HtmlPageContentModule } from "./pages/htmlpagecontent/htmlpagecontent.module";

import {ClaimsComponent} from './pages/claims/claims.component';

import {NavigationBarModule} from './openaireLibrary/sharedComponents/navigationBar.module';

import { CookieLawModule } from './openaireLibrary/sharedComponents/cookie-law/cookie-law.module';

import {BottomModule} from './openaireLibrary/sharedComponents/bottom.module';

import {FeedbackModule} from './openaireLibrary/sharedComponents/feedback/feedback.module';

import {CommunityEditFormModule} from './pages/community/community-edit-form/community-edit-form.module';

import {ZenodoCommunitiesModule} from './pages/zenodo-communities/zenodo-communities.module';

import {ManageSubscribersModule} from './pages/subscribers/manage-subscribers.module';

import {SubjectsEditFormModule} from './pages/subjects/subjects-edit-form/subjects-edit-form.module';

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

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

import { AdminLoginGuard} from './openaireLibrary/login/adminLoginGuard.guard';

import { ConnectAdminLoginGuard} from './openaireLibrary/connect/communityGuard/connectAdminLoginGuard.guard';

import { EnvironmentSpecificResolver} from './openaireLibrary/utils/properties/environmentSpecificResolver';

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

import{ClaimsAdminModule} from './openaireLibrary/claims/claimsAdmin/claimsAdmin.module';

import {StatsComponent} from "./pages/stats/stats.component";

//, , ErrorModule CookieLawModule

import { DataTablesModule } from 'angular-datatables';

import { CommunityProjectsModule } from './pages/community/projects/communityProjects.module';

import { CommunityContentProvidersModule } from './pages/community/content-providers/communityContentProviders.module';

import {InteractiveMiningModule} from 'interactiveminingv3';

import {MiningComponent} from './pages/mining/mining.component';

import {CommunitiesService} from "./openaireLibrary/connect/communities/communities.service";

import{CommunityErrorPageComponent} from './openaireLibrary/connect/communityGuard/communityErrorPage.component';

import {IsCommunity} from './openaireLibrary/connect/communityGuard/isCommunity.guard';

import {AdminErrorPageComponent} from './pages/error/errorPage.component';

import {ErrorModule} from './openaireLibrary/error/error.module';

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

import {WellcomeComponent} from './pages/wellcome/wellcome.component';

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

import {FABModule} from './utils/fabModule.module';

import {SafeHtmlPipeModule} from './openaireLibrary/utils/pipes/safeHTMLPipe.module';

import {ManageUserNotificationsModule} from './pages/usernotifications/manage-user-notifications.module';

@NgModule({

    imports: [

        BrowserModule,

        routing,

        HttpModule,

        JsonpModule,

        ModalModule.forRoot(),

        //CollapseModule.forRoot(),

        //AccordionModule.forRoot(),

        FormsModule,

        ReactiveFormsModule,

        // JWBootstrapSwitchModule,

        CKEditorModule,

        BottomModule, FeedbackModule, NavigationBarModule, CookieLawModule, ClaimsAdminModule,

        CommunityProjectsModule,

        CommunityContentProvidersModule,

        CommunityEditFormModule,

        ZenodoCommunitiesModule,

        ManageSubscribersModule,

        SubjectsEditFormModule,

        DataTablesModule,

        InteractiveMiningModule,

        ErrorModule,

        AlertModalModule, SafeHtmlPipeModule, FABModule,

        HtmlPageContentModule,

        // DivIdModule,

        // DivHelpContentsModule

        //DeleteConfirmationDialogModule

        // , CookieLawModule, ErrorModule

        ManageUserNotificationsModule

    ],

    declarations: [

        AppComponent,

        DashboardComponent,

        TopicsComponent,

        QuestionsComponent,

        TopicsFormComponent,

        ModalFormComponent,

        QuestionsFormComponent,

        DeleteConfirmationDialogComponent,

        PagesComponent,

        PageFormComponent,

        PageHelpContentsComponent,

        NewPageHelpContentComponent,

        PageContentFormComponent,

        EditPageHelpContentComponent,

        CommunitiesComponent,

        CommunityFormComponent,

        EntitiesComponent,

        EntityFormComponent,

        DivIdsComponent,

        DivIdFormComponent,

        DivHelpContentsComponent,

        NewDivHelpContentComponent,

        EditDivHelpContentComponent,

        DivContentFormComponent,

        ClaimsComponent,

        StatsComponent,

        MiningComponent,

        CommunityErrorPageComponent,

        AdminErrorPageComponent,

        WellcomeComponent

    ],

    providers: [

        FAQService,

        HelpContentService,

        appRoutingProviders,

        FreeGuard, AdminLoginGuard,ConnectAdminLoginGuard,LoginGuard,

        EnvironmentSpecificResolver,EnvironmentSpecificService,

        IsCommunity, CommunitiesService, TitleCasePipe

    ],

    bootstrap: [ AppComponent ]

})

export class AppModule { }

/**

 * Created by stefania on 9/16/16.

 */

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

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

import { DashboardComponent } from "./dashboard.component";

import { CommunitiesComponent } from './pages/community/communities.component';

import { ZenodoCommunitiesComponent } from "./pages/zenodo-communities/zenodo-communities.component";

import { ManageSubscribersComponent } from "./pages/subscribers/manage-subscribers.component";

import { CommunityEditFormComponent } from "./pages/community/community-edit-form/community-edit-form.component";

import { SubjectsEditFormComponent } from "./pages/subjects/subjects-edit-form/subjects-edit-form.component";

import { EntitiesComponent } from "./pages/entity/entities.component";

import { PagesComponent } from "./pages/page/pages.component";

import { PageHelpContentsComponent } from "./pages/helpcontent/page-help-contents.component";

import { NewPageHelpContentComponent } from "./pages/helpcontent/new-page-help-content.component";

import { EditPageHelpContentComponent } from "./pages/helpcontent/edit-page-help-content.component";

import { DivIdsComponent } from "./pages/divId/divIds.component";

import { DivHelpContentsComponent } from "./pages/divhelpcontent/div-help-contents.component";

import { NewDivHelpContentComponent } from "./pages/divhelpcontent/new-div-help-content.component";

import { EditDivHelpContentComponent } from "./pages/divhelpcontent/edit-div-help-content.component";

import { EditHtmlPageContentComponent } from "./pages/htmlpagecontent/edit-htmlpage-content.component";

import {ClaimsComponent} from './pages/claims/claims.component';

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

import {IsCommunity} from './openaireLibrary/connect/communityGuard/isCommunity.guard';

import { AdminLoginGuard} from './openaireLibrary/login/adminLoginGuard.guard';

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

import { ConnectAdminLoginGuard} from './openaireLibrary/connect/communityGuard/connectAdminLoginGuard.guard';

import { EnvironmentSpecificResolver} from './openaireLibrary/utils/properties/environmentSpecificResolver';

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

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

import {StatsComponent} from "./pages/stats/stats.component";

import {MiningComponent} from './pages/mining/mining.component';

import{CommunityErrorPageComponent} from './openaireLibrary/connect/communityGuard/communityErrorPage.component';

import {AdminErrorPageComponent} from './pages/error/errorPage.component';

import { ManageProjectsComponent } from './pages/community/projects/manage-projects.component';

import { ManageContentProvidersComponent } from './pages/community/content-providers/manage-content-providers.component';

import {WellcomeComponent} from './pages/wellcome/wellcome.component';

import {ManageUserNotificationsComponent} from './pages/usernotifications/manage-user-notifications.component';

//TODO replace IsCommunity with ConnectAdminLoginGuard

//, IsCommunity

const appRoutes: Routes = [

    {

        path: '',

        component: WellcomeComponent,

        canActivate: [FreeGuard],resolve: { envSpecific: EnvironmentSpecificResolver  }

        // redirectTo: 'dashboard',

        // pathMatch: 'full'

    },

    {

        path: 'dashboard',

        component: DashboardComponent,

        canActivate: [IsCommunity, ConnectAdminLoginGuard],resolve: { envSpecific: EnvironmentSpecificResolver  }

    },

    {

        path: 'manage-user-notifications',

        component: ManageUserNotificationsComponent,

        canActivate: [IsCommunity, ConnectAdminLoginGuard], resolve: {envSpecific: EnvironmentSpecificResolver}

    },

    {

      path: 'communities',

      component: CommunitiesComponent,

      canActivate: [AdminLoginGuard],resolve: { envSpecific: EnvironmentSpecificResolver  }

    },

    {

      path: 'community-edit-form',

      component: CommunityEditFormComponent,

      canActivate: [IsCommunity,ConnectAdminLoginGuard],resolve: { envSpecific: EnvironmentSpecificResolver  }

    },

    {

      path: 'manage-zenodo-communities',

      component: ZenodoCommunitiesComponent,

      canActivate: [IsCommunity,ConnectAdminLoginGuard],resolve: { envSpecific: EnvironmentSpecificResolver  }

    },

    {

      path: 'manage-subscribers',

      component: ManageSubscribersComponent,

      canActivate: [IsCommunity,ConnectAdminLoginGuard],resolve: { envSpecific: EnvironmentSpecificResolver  }

    },

    {

      path: 'manage-subjects',

      component: SubjectsEditFormComponent,

      canActivate: [IsCommunity,ConnectAdminLoginGuard],resolve: { envSpecific: EnvironmentSpecificResolver  }