openaire-library/utils/configuration/configuration.service.ts

import {Injectable, OnDestroy} from '@angular/core';
import {HttpClient} from "@angular/common/http";
import {BehaviorSubject, from, Observable, of, Subscription} from 'rxjs';
import {map} from 'rxjs/operators';
import {EnvProperties} from "../properties/env-properties";
import {Portal} from "../entities/adminTool/portal";
import {Page} from "../entities/adminTool/page";

@Injectable({  providedIn: 'root' })
export class ConfigurationService{
  private communityInformation: BehaviorSubject<Portal> = new BehaviorSubject(null);
  private sub: Subscription = null;
  private source: Observable<Portal> = null;
  private promise: Promise<boolean> = null;

   constructor(private http: HttpClient ) {}

   ngOnDestroy() {
      this.clearSubscriptions();
   }

  clearSubscriptions() {
     if(this.sub) {
       this.sub.unsubscribe();
     }
   }

  /**
   * @deprecated
   */
   getCommunityInformation(properties:EnvProperties, community:string){
     let url = properties.adminToolsAPIURL +"/"+properties.adminToolsPortalType+"/" + community + '/full';
     return this.http.get((properties.useLongCache) ? (properties.cacheUrl + encodeURIComponent(url)) : url);
               //.map(res => res.json());
   }

  public initStaticCommunityInformation(communityInformation: Portal) {
    this.promise = new Promise<any>((resolve => {
            this.communityInformation.next(communityInformation);
            resolve();
    }));
  }
  public initCommunityInformation(properties:EnvProperties, community:string) {
    if(community == null) return;

    let url = properties.adminToolsAPIURL +"/" + properties.adminToolsPortalType + "/" + community + "/full";
    this.promise = new Promise<any>((resolve => {
      this.source = this.http.get<Portal>((properties.useLongCache) ? (properties.cacheUrl + encodeURIComponent(url)) : url);

        this.sub = this.source
          .subscribe(
          (communityInformation: Portal) => {
            this.communityInformation.next(communityInformation);
            resolve();
          },
          error => {
            this.communityInformation.error(error);
            resolve();
          });
    }));

  }

  public get communityInformationState(): Observable<Portal> {
    return this.communityInformation.asObservable();
  }

  /**
   * @deprecated
   */
   isEntityEnabled(APIUrl:string, community:string,entity: string){
     //console.log("isEntityEnabled:  "+entity);
     let url = "isEntityEnabled-"+entity;

    //  if(entity == "publication" || entity == "dataset" || entity == "datasource"){
    //     return Observable.of(new Object()).mapTo(false);
    //  }
    //  return Observable.of(new Object()).mapTo(true);
     return this.http.get(APIUrl + "/page")
               .pipe(map(res => true));
   }

  /**
   * @deprecated
   */
   isPageEnabled(properties:EnvProperties, community:string,router: string){
     let page_route: string = router.split('?')[0].substring(1);

     let url = properties.adminToolsAPIURL + "/"+properties.adminToolsPortalType+"/" + community+"/pages?page_route="+page_route;
      return this.http.get((properties.useLongCache) ? (properties.cacheUrl + encodeURIComponent(url)) : url)
              //.map(res => res.json())
              .pipe(map(res => {
                let result = false;
                if(res['length'] >0 && res[0].route == page_route){
                  result =  res[0].isEnabled;
                }

                return result;
              }));//.do(res => {console.log("Route "+page_route +" is "+res)});
   }

  async isPageEnabledByStateAsync(properties: EnvProperties, community:string, page_route: string) {
     if(!this.promise) {
       this.initCommunityInformation(properties, community);
     }

     await this.promise;
     if(this.sub){
       this.sub.unsubscribe();
     }
     return this.filtering(page_route);
  }

  isPageEnabledByState(properties: EnvProperties, community:string, router: string): Observable<boolean> {
     let page_route: string = router.split('?')[0].substring(1);
     return from(this.isPageEnabledByStateAsync(properties, community, page_route));
  }

  filtering(page_route: string) {
      let community: Portal = this.communityInformation.getValue();
      let pages: Page[] = <Page[]>community.pages;
      if (pages) {
        let page = pages.find((page: Page) => page.route == page_route);
        return page && page.isEnabled;
      } else {
        return false;
      }
  }

  /**
   * @deprecated
   */
  getMainPageContent(APIUrl:string, community:string,){
     return this.http.get(APIUrl + "/page")
               .pipe(map(res => true));
   }

  /**
   * @deprecated
   */
  getSpecialAnouncementContent(APIUrl:string, community:string,){
     return this.http.get(APIUrl + "/page")
               .pipe(map(res => ""));
   }

  /**
   * @deprecated
   */
  getHelpPageContent(APIUrl:string, community:string, router:string){
     return  this.http.get(APIUrl + "/page")
               .pipe(map(res => true));
   }
    // 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 this.http.get(this.APIUrl + "/page")
    //               .map(res => true);
    // }


}