D-Net

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') 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.ERROR;

                } // this.handleError('System error retrieving community profile', error)

              );

            },

            error => {

              console.log('Community couldn\'t be loaded');

              this.zenodoSearchUtils.status = this.errorCodes.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');

      }

    ));

  }

}