D-Net

import {FormBuilder} from "@angular/forms";

import {ConnectHelper} from '../../../openaireLibrary/connect/connectHelper';

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

import {Body} from '../../../openaireLibrary/utils/email/body';

import {Validator} from '../../../openaireLibrary/utils/email/validator';

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

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

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

import {ErrorCodes} from '../../../openaireLibrary/utils/properties/errorCodes';

import {ErrorMessagesComponent} from '../../../openaireLibrary/utils/errorMessages.component';

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

import {HelperFunctions} from "../../../openaireLibrary/utils/HelperFunctions.class";

import {PiwikHelper} from "../../piwikHelper";

  @Input() buttonSizeSmall = true;

  @Input() properties: EnvProperties;

  public community = null;

  //public showLoading: boolean = true;

  public errorMessage: string = '';

  public successfulSentMessage: string = '';

  public successfulSentRecipients: string[] = [];

  public failureSentMessage: string = '';

  public failureSentRecipients: string[] = [];

  public inviteErrorMessage: string = '';

  public missingCommunityId: string = '';

  public showAddRecipientMessage: boolean = false;

  public showAddNameMessage: boolean = false;

  public email: Email;

  public body: Body;

  public recipients: string;

  public fullname: string;

  public areValid: boolean = true;

  private ckeditorContent: string;

  // public defaultBody ='';

  public communityIdParam = {};

  public status: number = 1;

  public errorCodes: ErrorCodes;

  private errorMessages: ErrorMessagesComponent;

  public pageContents = null;

  public divContents = null;

  public url: string = null;

  private user: User;

  subs: Subscription[] = [];

    public _fb: FormBuilder,

    private _emailService: EmailService,

    private _communityService: CommunityService,

    private _meta: Meta,

    this.errorCodes = new ErrorCodes();

    this.errorMessages = new ErrorMessagesComponent();

    this.status = this.errorCodes.LOADING;

    if(!this.properties) {

      this.properties = properties;

    }

    if(this.properties) {

      this.errorMessage = "";

      this.missingCommunityId = "";

      this.status = this.errorCodes.LOADING;

      this.subs.push(this.userManageService.getUserInfo().subscribe(

        user => {

          this.user = user;

          this.init();

        },

        error => {

          this.init();

        }

      ));

      //this.init();

    }

  private init() {

    this.subs.push(this.route.queryParams.subscribe(

      communityId => {

        //if(!this.communityId && typeof document !== 'undefined'){

        this.communityId = ConnectHelper.getCommunityFromDomain(this.properties.domain);

        if (!this.communityId) {

          this.communityId = communityId['communityId'];

        }

        if (this.longView) {

          if (this.properties.enablePiwikTrack && (typeof document !== 'undefined')) {

            this.subs.push(this._piwikService.trackView(this.properties, this.pageTitle, PiwikHelper.getSiteId(this.communityId, this.properties.environment)).subscribe());

          }

          this.url = this.properties.domain + this._router.url;

          this.seoService.createLinkForCanonicalURL(this.url);

          this.updateUrl(this.url);

          this.updateTitle(this.pageTitle);

          this.updateDescription("OpenAIRE - Connect, Community Gateway, research community, invite");

        }

        this.communityIdParam = (this.properties.environment != "development") ? {} : {communityId: this.communityId};

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

          //this.getDivContents();

          this.getPageContents();

          this.subs.push(this._communityService.getCommunityAsObservable().subscribe(

            community => {

              this.community = community;

              this.fullname = (this.user) ? this.user.fullname : null;

              //console.log("Fullname from session " + Session.getUserFullName());

              this.body = Composer.initializeInvitationsBody(this.communityId, this.community.title, this.fullname);

              this.email = Composer.initializeInvitationsEmail(community.title);

              this.recipients = "";

              this.status = this.errorCodes.DONE;

            },

            error => {

              //this.handleError(error)

              this.handleError("Error getting community with id: " + this.communityId, error);

              this.status = this.errorMessages.getErrorCode(error.status);

            }

          ));

        } else {

          this.status = this.errorCodes.DONE;

          this.missingCommunityId = "There is no community selected!";

        }

      }));

  }

  public invite() {

    this.successfulSentMessage = "";

    this.failureSentMessage = "";

    this.inviteErrorMessage = "";

    this.status = this.errorCodes.LOADING;

    HelperFunctions.scroll();

    if (!this.isEmpty(this.recipients) && this.body.fromName != "") {

      if (this.validateEmails()) {

        this.composeEmail();

        this.subs.push(this._emailService.sendEmail(this.properties, this.email).subscribe(

          res => {

            this.status = this.errorCodes.DONE;

            if (res['success']) {

              this.successfulSentMessage = "Email sent successfully to: ";

              this.successfulSentRecipients = res['success'];

            }

            if (res['failure']) {

              this.failureSentMessage = "There was an error sending email to: ";

              this.failureSentRecipients = res['failure'];

            }

            this.body = Composer.initializeInvitationsBody(this.communityId, this.community.title, this.fullname);

            this.email = Composer.initializeInvitationsEmail(this.community.title);

            this.recipients = "";

          },

          error => {

            //console.log(error);

            this.handleError("Error inviting emails: " + JSON.stringify(this.recipients) + " to community with id: " + this.communityId + " by: " + this.fullname, error);

            this.status = this.errorCodes.DONE;

            this.inviteErrorMessage = "There was an error sending emails. Please try again.";

          }

        ));

      } else {

        this.email.recipients = [];

        this.status = this.errorCodes.DONE;

      }

    } else {

      this.showAddRecipientMessage = true;

      this.status = this.errorCodes.DONE;

    }

  }

  public isEmpty(data: string): boolean {

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

  }

  public resetMessages() {

    this.errorMessage = "";

    this.successfulSentMessage = "";

    this.failureSentMessage = "";

    this.inviteErrorMessage = "";

  }

  public validateEmails(): boolean {

    if (this.parseEmails()) {

      if (Validator.hasValidEmails(this.email.recipients)) {

        return this.areValid;

      }

    }

    this.areValid = false;

    return this.areValid;

  }

  public parseEmails(): boolean {

    let email = new Array<string>();

    // remove spaces

    this.recipients = this.recipients.replace(/\s/g, '');

    // remove commas

    email = this.recipients.split(",");

    // remove empty fields

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

      if (!(email[i] == "")) {

        this.email.recipients.push(email[i]);

      }

    }

    return true;

  }

  public composeEmail() {

    this.email.body = Composer.formatEmailBodyForInvitation(this.body);

  }

  allowEdit() {

    if (!this.user) {

      return false;

    }

    var email = this.user.email;

    var index = -1;

    if (email && this.community != null && this.community.managers != null) {

      index = this.community.managers.indexOf(email);

    }

    return Session.isPortalAdministrator(this.user) || Session.isCommunityCurator(this.user) || index != -1;

  }

  private handleError(message: string, error) {

    console.error("Invite Page (or component): " + message, error);

  }