connect-admin/src/app/pages/zenodo-communities/zenodo-communities.component.ts

import {Component, ElementRef, OnDestroy, OnInit, ViewChild} from '@angular/core';
import {ActivatedRoute, Router} from '@angular/router';

import {Session} from '../../openaireLibrary/login/utils/helper.class';
import {LoginErrorCodes} from '../../openaireLibrary/login/utils/guardHelper.class';
import {EnvProperties} from '../../openaireLibrary/utils/properties/env-properties';
import {ZenodoCommunitiesService} from '../../openaireLibrary/connect/zenodoCommunities/zenodo-communities.service';
import {SearchZenodoCommunitiesService} from '../../openaireLibrary/connect/zenodoCommunities/searchZenodoCommunities.service';

import {CommunityService} from '../../openaireLibrary/connect/community/community.service';
import {CommunityInfo} from '../../openaireLibrary/connect/community/communityInfo';
import {ZenodoCommunityInfo} from '../../openaireLibrary/connect/zenodoCommunities/zenodoCommunityInfo';
import {SearchUtilsClass} from '../../openaireLibrary/searchPages/searchUtils/searchUtils.class';
import {ErrorCodes} from '../../openaireLibrary/utils/properties/errorCodes';
import {HelperFunctions} from '../../openaireLibrary/utils/HelperFunctions.class';
import {Title} from '@angular/platform-browser';
import {properties} from '../../../environments/environment';
import {Subscription} from 'rxjs';
import {FullScreenModalComponent} from '../../openaireLibrary/utils/modal/full-screen-modal/full-screen-modal.component';
import {ManageZenodoCommunitiesComponent} from './manage-zenodo-communities.component';

@Component({
  selector: 'zenodo-communities',
  template: `
    <div *ngIf="zenodoSearchUtils.status == errorCodes.LOADING" page-content>
      <div header>
        <community-info tab="zenodo-communities"></community-info>
      </div>
      <div inner>
        <div class="uk-position-center">
          <loading></loading>
        </div>
      </div>
    </div>
    <ng-container *ngIf="zenodoSearchUtils.status != errorCodes.LOADING">
      <manage-zenodo-communities #manage *ngIf="communityId && zenodoSearchUtils" [masterCommunity]=masterZenodoCommunity [selectedCommunities]=selectedCommunities
                                 [properties]=properties [communityId]=communityId [searchUtils]=zenodoSearchUtils
                                 (toggleView)="toggleAction()"></manage-zenodo-communities>
    </ng-container>
    <fs-modal #fsModal (cancelEmitter)="toggleAction()">
      <add-zenodo-communities *ngIf="zenodoSearchUtils.status != errorCodes.LOADING" [masterCommunity]=masterZenodoCommunity [selectedCommunities]=selectedCommunities
                              [properties]=properties [communityId]=communityId></add-zenodo-communities>
    </fs-modal>
  `
})
export class ZenodoCommunitiesComponent implements OnInit, OnDestroy {
  public communityId: string = null;
  private community: CommunityInfo = null;
  public toggle = false;
  public updateCommunityProjectsOnToggle = false;
  public pageTitle = 'Manage zenodo communities';
  masterZenodoCommunityId = null;
  masterZenodoCommunity = null;
  public properties: EnvProperties = null;
  selectedCommunityIds = null;
  selectedCommunities = [];
  zenodocommunitiesloadedCount = 0;
  zenodoSearchUtils: SearchUtilsClass = new SearchUtilsClass();
  public errorCodes: ErrorCodes = new ErrorCodes();
  subscriptions = [];
  @ViewChild('fsModal', { static: true }) fullscreen: FullScreenModalComponent;
  @ViewChild('manage') manage: ManageZenodoCommunitiesComponent;
  
  constructor(private element: ElementRef, private route: ActivatedRoute, private _router: Router,
              private _zenodoCommunitieService: ZenodoCommunitiesService, private title: Title,
              private _communityService: CommunityService,
              private _searchZenodoCommunitiesService: SearchZenodoCommunitiesService) {
  }
  
  ngOnInit() {
    this.zenodoSearchUtils.status = this.errorCodes.LOADING;
    this.properties = properties;
    this.route.params.subscribe(params => {
      this.communityId = params['community'];
      if (this.communityId) {
        this.title.setTitle(this.communityId.toUpperCase() + ' | Zenodo Communities');
        if (this.communityId != null && this.communityId !== '') {
          this.subscriptions.push(this._communityService.getCommunityAsObservable().subscribe(
            community => {
              this.community = community;
              this.masterZenodoCommunityId = this.community.zenodoCommunity;
              if (this.masterZenodoCommunityId) {
                this.subscriptions.push(this._zenodoCommunitieService.getZenodoCommunityById(this.properties,
                  this.properties.zenodoCommunities + this.masterZenodoCommunityId,
                  null).subscribe(
                  result => {
                    this.masterZenodoCommunity = result;
                  },
                  error => {
                    const emptyCommunity: ZenodoCommunityInfo = new ZenodoCommunityInfo();
                    emptyCommunity.id = this.masterZenodoCommunityId;
                    emptyCommunity.title = this.masterZenodoCommunityId;
                    this.masterZenodoCommunity = emptyCommunity;
                    // console.log("Master Zenodo community'"+this.masterZenodoCommunityId+"' couldn't be loaded");
                  }
                ));
              }
              this.zenodoSearchUtils.status = this.errorCodes.LOADING;
              this._searchZenodoCommunitiesService.searchZCommunities(this.properties, this.communityId).subscribe(
                result => {
                  this.selectedCommunityIds = result;
                  this.zenodoSearchUtils.totalResults = this.selectedCommunityIds.length;
                  if (this.selectedCommunityIds.length === 0) {
                    this.zenodoSearchUtils.status = this.errorCodes.NONE;
                  }
                  for (let i = 0; i < this.selectedCommunityIds.length; i++) {
                    this.getZenodoCommunityById(
                      this.selectedCommunityIds[i]['zenodoid'],
                      this.selectedCommunityIds[i]['id']);
                  }
                  
                },
                error => {
                  console.log('list of zenodo communities couldn\'t be loaded');
                  this.zenodoSearchUtils.status = this.errorCodes.DONE;
                } // this.handleError('System error retrieving community profile', error)
              );
            }));
        }
      }
    });
    this.fullscreen.title = "Search and Add Zenodo Communities";
    this.fullscreen.okButtonText = "Done";
    this.fullscreen.okButton = true;
  }
  
  ngOnDestroy() {
    this.subscriptions.forEach(subscription => {
      if (subscription instanceof Subscription) {
        subscription.unsubscribe();
      }
    });
  }
  
  public toggleAction() {
    if (!Session.isLoggedIn()) {
      this._router.navigate(['/user-info'], {
        queryParams: {'errorCode': LoginErrorCodes.NOT_VALID, 'redirectUrl': this._router.url}
      });
    } else {
      HelperFunctions.scroll();
      
      this.toggle = !this.toggle;
      if (this.toggle) {
        this.fullscreen.open();
        this.pageTitle = 'Manage zenodo communities';
      } else {
        this.manage.filterPreviewCommunities(this.manage.filterForm.value);
        this.updateCommunityProjectsOnToggle = false;
        this.pageTitle = 'Search zenodo communities';
      }
    }
  }
  
  getZenodoCommunityById(zenodoid, openaireId) {
    this.subscriptions.push(this._zenodoCommunitieService.getZenodoCommunityById(this.properties,
      this.properties.zenodoCommunities + zenodoid, openaireId).subscribe(
      result => {
        this.selectedCommunities.push(result);
        this.zenodocommunitiesloadedCount++;
        if (this.zenodocommunitiesloadedCount >= this.selectedCommunityIds.length) {
          this.zenodoSearchUtils.status = this.errorCodes.DONE;
        }
        
        
      },
      error => {
        const emptyCommunity: ZenodoCommunityInfo = new ZenodoCommunityInfo();
        emptyCommunity.id = zenodoid;
        emptyCommunity.openaireId = openaireId;
        emptyCommunity.title = zenodoid;
        this.selectedCommunities.push(emptyCommunity);
        this.zenodocommunitiesloadedCount++;
        if (this.zenodocommunitiesloadedCount >= this.selectedCommunityIds.length) {
          this.zenodoSearchUtils.status = this.errorCodes.DONE;
        }
        console.log('Zenodo community\'' + zenodoid + '\' couldn\'t be loaded');
      }
    ));
  }
}