D-Net

/**

 * Created by stefania on 7/13/17.

 */

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

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

import { ActivatedRoute } from "@angular/router";

import { DeleteConfirmationDialogComponent } from "../delete-confirmation-dialog.component";

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

import { PageHelpContent, CheckPageHelpContent, PageHelpContentFilterOptions } from "../../domain/page-help-content";

import { Page } from "../../domain/page";

import {Router} from "@angular/router";

import { Community } from "../../domain/community";

@Component({

    selector: 'page-help-contents',

    templateUrl: './page-help-contents.component.html',

})

export class PageHelpContentsComponent implements OnInit {

    // @ViewChild(ModalFormComponent)

    // @ViewChild('saveModal')

    // public modal:ModalFormComponent;

    //

    // @ViewChild('updateModal')

    // public updateModal:ModalFormComponent;

    //

    // @ViewChild(PageHelpContentsFormComponent)

    // public formComponent : PageHelpContentsFormComponent;

    @ViewChild('deleteConfirmationModal')

    public deleteConfirmationModal : DeleteConfirmationDialogComponent;

    public pageHelpContentsCheckboxes : CheckPageHelpContent[] = [];

    public pageHelpContents : PageHelpContent[] = [];

    public errorMessage: string;

    public formGroup : FormGroup;

    public pages: Page[];

    public checkboxAll : boolean = false;

    public filters : PageHelpContentFilterOptions = {id : '', active : null, text : new RegExp('')};

    public counter = {all : 0, active : 0, inactive : 0};

    public communities: Community[] = [];

    public selectedCommunityId: string;

    public selectedPageId: string;

    public pageType: string;

    ngOnInit() {

      this.route.queryParams.subscribe(params => {

        this.selectedCommunityId = params['community'];

        this.selectedPageId = params['page'];

        if(this.selectedCommunityId && this.selectedPageId) {

          this.getPageHelpContents(this.selectedCommunityId);

          this.getPage(this.selectedPageId);

        } else {

          this.selectedPageId = "";

          this.getCommunities();

        }

      });

        // this.formGroup = this.formComponent.form;

    }

    constructor(private route: ActivatedRoute, private _helpService: HelpContentService, private router : Router) {}

    getPage(pageId: string) {

      let self = this;

      this._helpService.getPage(pageId).subscribe(

          page => {

              self.pageType = page.type;

            }

          );

    }

    getCommunities() {

        let self = this;

        this._helpService.getCommunities().subscribe(

            communities => {

                self.communities = communities;

                self.selectedCommunityId = self.communities[0]._id;

                this.getPages(self.selectedCommunityId);

                this.getPageHelpContents(self.selectedCommunityId);

        },

        error => this.handleError('System error retrieving communities', error));

    }

    getPages(community_id: string) {

        this._helpService.getCommunityPages(community_id).subscribe(

            pages => this.pages = pages,

            error => this.handleError('System error retrieving pages', error));

    }

    public countPageHelpContents() {

        this.counter = {all : 0, active : 0, inactive : 0};

        let filter = Object.assign({},this.filters);

        filter.active = null;

        this.pageHelpContents.forEach(_ => {

            if(this.filterPageHelpContent(_,filter)){

                if (_.isActive==true) this.counter.active++;

                else this.counter.inactive++

            }

        });

        this.counter.all = this.counter.active + this.counter.inactive;

    }

    getPageHelpContents(community_id: string) {

        let self = this;

        this._helpService.getCommunityPageHelpContents(community_id).subscribe(

            pageHelpContents => {

                self.pageHelpContents = pageHelpContents as Array<PageHelpContent>;

                self.counter.all = self.pageHelpContents.length;

                self.pageHelpContentsCheckboxes = [];

                /*self.pageHelpContents.forEach(_ => {

                  let page: Page = _.page as Page;

                  if(!self.selectedPageId || (page._id == self.selectedPageId)) {

                    self.pageHelpContentsCheckboxes.push(<CheckPageHelpContent>{pageHelpContent : _, checked : false});

                  }

                });*/

                for (let i = self.pageHelpContents.length - 1; i >= 0; i -= 1) {

                  let page: Page =  self.pageHelpContents[i].page as Page;

                  if(!self.selectedPageId || (page._id == self.selectedPageId)) {

                    self.pageHelpContentsCheckboxes.push(<CheckPageHelpContent>{pageHelpContent : self.pageHelpContents[i], checked : false});

                  } else {

                    self.pageHelpContents.splice(i, 1);

                  }

                }

                self.countPageHelpContents();

            },

            error => this.handleError('System error retrieving page contents', error));

    }

    // public showModal():void {

    //     this.modal.showModal();

    // }

    public toggleCheckBoxes(event) {

        this.pageHelpContentsCheckboxes.forEach(_ => _.checked = event.target.checked);

        this.checkboxAll = event.target.checked;

    }

    public applyCheck(flag : boolean) {

        this.pageHelpContentsCheckboxes.forEach(_ => _.checked = flag);

        this.checkboxAll = false;

    }

    public getSelectedPageHelpContents() : string[] {

        return this.pageHelpContentsCheckboxes.filter(pageHelpContent => pageHelpContent.checked == true)

            .map(checkedPageHelpContent => checkedPageHelpContent.pageHelpContent).map(res => res._id);

    }

    public confirmDeletePageHelpContent(id : string) {

        this.deleteConfirmationModal.ids = [id];

        this.deleteConfirmationModal.showModal();

    }

    public confirmDeleteSelectedPageHelpContents() {

        this.deleteConfirmationModal.ids = this.getSelectedPageHelpContents();

        this.deleteConfirmationModal.showModal();

    }

    public confirmedDeletePageHelpContents(ids : string[]) {

        this._helpService.deletePageHelpContents(ids).subscribe(

            _ => this.deletePageHelpContentsFromArray(ids),

            error => this.handleError('System error deleting the selected page content(s)', error)

        );

    }

    private deletePageHelpContentsFromArray(ids : string[]) : void {

        for(let id of ids) {

            let iqc = this.pageHelpContentsCheckboxes.findIndex(_ => _.pageHelpContent._id == id);

            let iq = this.pageHelpContents.findIndex(_ => _._id == id);

            this.pageHelpContentsCheckboxes.splice(iqc, 1);

            this.pageHelpContents.splice(iqc, 1);

        }

    }

    public editPageHelpContent(_id : string) {

        //this.router.navigate(['/pageContents/edit/', _id]);

        if(this.selectedPageId) {

          this.router.navigate( ['/pageContents/edit/'], { queryParams: { "pageContentId": _id, "communityId": this.selectedCommunityId, "pageId": this.selectedPageId  } } );

        } else {

          this.router.navigate( ['/pageContents/edit/'], { queryParams: { "pageContentId": _id, "communityId": this.selectedCommunityId } } );

        }

    }

    public togglePageHelpContents(status : boolean, ids : string[]) {

        this._helpService.togglePageHelpContents(ids,status).subscribe(

            () => {

                for(let id of ids) {

                    let i = this.pageHelpContentsCheckboxes.findIndex(_ => _.pageHelpContent._id == id);

                    console.info(i);

                    this.pageHelpContentsCheckboxes[i].pageHelpContent.isActive=status;

                }

                this.countPageHelpContents();

                this.applyCheck(false);

            },

            error => this.handleError('System error changing the status of the selected page content(s)', error)

        );

    }

    public savePageHelpContent(data : any):void {

        console.log(data);

        this._helpService.savePageHelpContent(data).subscribe(

            pageHelpContent => this.pageHelpContentSavedSuccessfully(pageHelpContent),

            error => this.handleError('System error saving the specified help content', error)

        );

    }

    public pageHelpContentSavedSuccessfully(pageHelpContent: PageHelpContent) {

        this.pageHelpContentsCheckboxes.push(<CheckPageHelpContent>{pageHelpContent : pageHelpContent, checked : false});

        this.pageHelpContents.push(pageHelpContent);

        this.applyCheck(false);

        this.countPageHelpContents();

    }

    public pageHelpContentUpdatedSuccessfully(pageHelpContent : PageHelpContent) {

        this.pageHelpContentsCheckboxes.find(checkItem => checkItem.pageHelpContent._id==pageHelpContent._id).pageHelpContent = pageHelpContent;

        let index = this.pageHelpContents.findIndex(checkItem => checkItem._id==pageHelpContent._id);

        this.pageHelpContents[index] = pageHelpContent;

        this.applyCheck(false);

        this.countPageHelpContents();

    }

    public filterPageHelpContent(pageHelpContent : PageHelpContent, filters : PageHelpContentFilterOptions) : boolean {

        let idFlag = filters.id == '' || (<Page>pageHelpContent.page)._id == filters.id;

        let activeFlag = filters.active == null || pageHelpContent.isActive == filters.active;

        let textFlag = filters.text.toString() == '' || (pageHelpContent.content).match(filters.text) != null;

        return idFlag && activeFlag && textFlag;

    }

    public applyFilter() {

        this.pageHelpContentsCheckboxes = [];

        this.pageHelpContents.filter(item => this.filterPageHelpContent(item,this.filters)).forEach(

            _ => this.pageHelpContentsCheckboxes.push(<CheckPageHelpContent>{pageHelpContent: _, checked: false})

        );

        this.countPageHelpContents();

    }

    public filterByPage(event: any) {

        this.filters.id = event.target.value;

        this.applyFilter();

    }

    public displayAllPageHelpContents() {

        this.filters.active = null;

        this.applyFilter();

    }

    public displayActivePageHelpContents() {

        this.filters.active = true;

        this.applyFilter();

    }

    public filterBySearch(text : string) {

        this.filters.text = new RegExp(text, "i");

        this.applyFilter();

    }

    public displayInactivePageHelpContents() {

        this.filters.active = false;

        this.applyFilter();

    }

    handleError(message: string, error) {

        if(error == null) {

            // this.formComponent.reset();

        }

        this.errorMessage = message + ' (Server responded: ' + error + ')';

    }

    public filterByCommunity(event: any) {

        this.selectedCommunityId = event.target.value;

        this.applyCommunityFilter(this.selectedCommunityId);

    }

    public applyCommunityFilter(community_id: string) {

        this.getPages(community_id);

        this.getPageHelpContents(community_id);

    }

}