D-Net

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

import {SimpleChanges, OnChanges}                        from '@angular/core';

import {FormGroup, FormArray, FormBuilder, Validators}   from "@angular/forms";

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

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

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

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

import {EmailService}                                    from "../../../openaireLibrary/utils/email/email.service";

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

import {CommunityInfo}                                   from '../../../openaireLibrary/connect/community/communityInfo';

import {Email}                                           from "../../../openaireLibrary/utils/email/email";

import {Composer}                                        from "../../../openaireLibrary/utils/email/composer";

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

import {LoginErrorCodes} from '../../../openaireLibrary/login/utils/guardHelper.class';

@Component({

    selector: 'community-edit-form',

    templateUrl: './community-edit-form.component.html',

})

export class CommunityEditFormComponent implements OnInit{

    @Input('group')

    myForm: FormGroup;

    public showLoading: boolean = true;

    public errorMessage: string = '';

    public updateErrorMessage: string = '';

    public successfulSaveMessage: string = '';

    public successfulResetMessage: string = '';

    public hasChanged: boolean = false;

    public res=[];

    params: any;

    public communityId = null;

    public community = null;

    public firstVersionOfManagers: string[];

    public newManagersToSubscribe: string[];

    public email: Email;

    public emailToInform: Email;

    public note: string = '';

    public properties:EnvProperties = null;

    constructor (private element: ElementRef,

                 private route: ActivatedRoute,

                 private _router: Router,

                 public _fb: FormBuilder,

                 private _helpContentService: HelpContentService,

                 private _communityService: CommunityService,

                 private _subscribeService: SubscribeService,

                 private _emailService: EmailService){ }

    ngOnInit() {

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

            this.properties = data.envSpecific;

            this.route.queryParams.subscribe(

              communityId => {

                    this.scroll();

                    this.communityId = communityId['communityId'];

                    this.email = {body: "", subject: "", recipients: []};

                    this.emailToInform = {body: "", subject: "", recipients: []};

                    if(!Session.isLoggedIn()){

                      console.info(this._router.url);

                      this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });

                    } else {

                      if (this.communityId != null && this.communityId != '') {

                          this.showLoading = true;

                          this.updateErrorMessage = "";

                          this.errorMessage = "";

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

                            community => {

                                  this.community = community;

                                  this.params = {community: encodeURIComponent('"'+community.queryId+'"')};

                                  this.firstVersionOfManagers = community.managers.slice();

                                  console.log("First version of managers " + this.firstVersionOfManagers);

                                  console.log(community);

                                  this.showLoading = false;

                            },

                            error => this.handleError('System error retrieving community profile', error)

                          );

                      }

                    }

             });

        });

    }

    public scroll() {

      console.info("scroll into view");

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

         this.element.nativeElement.scrollIntoView();

      }

    }

    public addManager() {

            this.community.managers.push("");

    }

    public removeManager(i : any) {

            this.community.managers.splice(i,1);

    }

    // public addSubject() {

    //         this.community.subjects.push("");

    // }

    //

    // public removeSubject(i : any) {

    //         this.community.subjects.splice(i,1);

    // }

    public resetForm(communityId: string) {

      if(!Session.isLoggedIn()){

        console.info(this._router.url);

        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });

      } else {

        if (communityId != null && communityId != '') {

            this.showLoading = true;

            this.updateErrorMessage = "";

            this.errorMessage = "";

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

              community => {

                    this.community = community;

                    this.params = {community: encodeURIComponent('"'+community.queryId+'"')};

                    this.showLoading = false;

                    this.handleSuccessfulReset('Form reseted!')

              },

              error => this.handleError('System error retrieving community profile', error)

            );

        }

        this.resetChange();

      }

    }

    public updateCommunity() {

      if(!Session.isLoggedIn()){

        console.info(this._router.url);

        this._router.navigate(['/user-info'], { queryParams: { "errorCode": LoginErrorCodes.NOT_VALID, "redirectUrl":  this._router.url} });

      } else {

        if (this.communityId != null && this.communityId != '') {

            this.showLoading = true;

            var community = this.parseUpdatedCommunity();

            // TODO delete after testing

            console.log(community);

            if (!this.hasValidEmail(community) || !this.hasFilled(community["name"])) {

                this._router.navigate(['/community-edit-form'], {queryParams: { "communityId": this.communityId}});

            } else {

                var newManagers = this.getNewManagers();

                this._communityService.updateCommunity(this.properties.communityAPI+this.communityId, community).subscribe(

                    community => {

                        // TODO delete after testing

                        console.log("New managers in component: " + newManagers);

                        if (newManagers !== null) {

                            this.sendMailToNewManagers(newManagers);

                            console.log("Old managers in component: " + this.firstVersionOfManagers);

                            this.informOldManagersForTheNewOnes(this.firstVersionOfManagers);

                            for (let i = 0; i < newManagers.length; i++) {

                                console.log(newManagers[i]);

                                this._subscribeService.subscribeToCommunity(this.communityId, newManagers[i], this.properties.adminToolsAPIURL).subscribe(

                                    res => {

                                        console.log(res);

                                    }

                                );

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

                                    res => {

                                        console.log(res);

                                    }

                                );

                            }

                        }

                        this.handleSuccessfulSave('Community saved!')

                    },

                    error => {

                        this.handleUpdateError('System error updating community profile', error)

                    },

                    () => { this.firstVersionOfManagers = this.community["managers"].slice(); }

                );

                this._router.navigate(['/community-edit-form'], {queryParams: { "communityId": this.communityId}});

            }

        }

        this.resetChange();

      }

    }

    private parseUpdatedCommunity() : {} {

        var community = {};

        community["name"] = this.community.title;

        community["shortName"] = this.community.shortTitle;

        community["status"] = this.community.status;

        community["description"] = this.community.description;

        community["logoUrl"] = this.community.logoUrl;

        community['managers'] = new Array<string>();

        this.community.managers = this.getNonEmptyItems(this.community.managers);

        community['managers'] = this.community.managers;

        return community;

    }

    private getNewManagers(): Array<string> {

        let newManagers = null;

        for (let i = 0; i < this.community['managers'].length; i++) {

            if (!this.firstVersionOfManagers.includes(this.community['managers'][i])) {

                if(newManagers ===  null){

                    newManagers = new Array<string>();

                }

                newManagers.push(this.community['managers'][i]);

            }

        }

        console.log("New managers are: " + newManagers);

        return newManagers;

    }

    private sendMailToNewManagers(managers: any) {

        this._emailService.sendEmail(this.properties.adminToolsAPIURL + "/sendMail/",

                                     Composer.composeEmailForNewManager(this.communityId, this.community.title, managers)).subscribe(

              res => {

                console.log("The email has been sent successfully!")

              },

              error => console.log(error)

        );

    }

    private informOldManagersForTheNewOnes(managers: any) {

        this._emailService.sendEmail(this.properties.adminToolsAPIURL + "/notifyForNewManagers/"  + this.communityId,

                                     Composer.composeEmailToInformOldManagersForTheNewOnes(this.community.title, this.communityId,

                                                                                           this.firstVersionOfManagers,

                                                                                           this.community.managers)).subscribe(

              res => {

                console.log("The email has been sent successfully!")

              },

              error => console.log(error)

        );

    }

    private subscribeNewManagers(newManagers: string[]): boolean {

        return true;

    }

    private getNonEmptyItems(data: string[]): string[] {

        let length = data.length;

        let arrayNonEmpty = new Array<string>();

        let j = 0;

        for (let i = 0; i < length; i++) {

            if (this.isEmpty(data[i])) {

                 //console.log(data[i]);

            } else if (this.isNonEmpty(data[i])) {

                 arrayNonEmpty[j] = data[i];

                 j++;

                 //console.log(data[i]);

            }

        }

        return arrayNonEmpty;

    }

    private hasFilled(data: any): boolean {

        if (this.isNonEmpty(data) && !this.isEmpty(data)) {

            // TODO remove console message after final testing

            console.log("NAME IS NOT EMPTY");

            return true;

        }

        // TODO remove console message after final testing

        console.log("NAME IS EMPTY");

        return false;

    }

    private isEmpty(data: string): boolean {

        if (data != undefined && !data.replace(/\s/g, '').length)

            return true;

        else

            return false;

    }

    private isNonEmpty(data: string): boolean {

        if (data != undefined && data != null)

            return true;

        else

            return false;

    }

    private hasValidEmail(data: any): boolean {

        let length = data['managers'].length;

        for(let i = 0; i < length; i++) {

            if (!this.emailValidator(data['managers'][i])){

                // TODO remove console message after final testing

                console.log("INVALID EMAIL");

                return false;

            }

        }

        // TODO remove console message after final testing

        console.log("ALL EMAILS ARE VALID");

        return true;

    }

    private emailValidator(email : any): boolean {

        if (email.match("^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,4}$"))

            return true;

        else

            return false;

    }

    private change() {

        this.hasChanged = true;

        this.successfulSaveMessage = '';

        this.successfulResetMessage = '';

        // TODO remove after testing

        console.log('I have changed: I AM TRUE');

    }

    private resetChange() {

        this.hasChanged = false;

        // TODO remove after testing

        console.log('I have changed: I AM FALSE');

    }

    public get form() {

        return this._fb.group({

            _id : '',

            name : ['', Validators.required]

        });

    }

    public reset() {

        this.myForm.patchValue({

            name : '',

            _id : ''

        });

    }

    handleUpdateError(message: string, error) {

        this.updateErrorMessage = message;

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

        this.showLoading = false;

    }

    handleError(message: string, error) {

        this.errorMessage = message;

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

        this.showLoading = false;

    }

    handleSuccessfulSave(message) {

        this.showLoading = false;

        this.successfulSaveMessage = message;

    }

    handleSuccessfulReset(message) {

        this.showLoading = false;

        this.successfulResetMessage = message;

    }

    trackByFn(index: any, item: any) {

        return index;

    }

}