src/app/filter/filter.component.ts

import { Component, Optional, OnInit, Output, EventEmitter, Input, OnChanges, SimpleChanges } from '@angular/core';
import { Responsibility } from '../model/responsibility';
import { TerritoryResponsibility } from '../model/territory-responsibility';
import { User } from '../model/user';
import { MessageService, MessageDefines } from '../services/message.service';
import { ResponsibilityComponent } from '../dialogs/responsibility/responsibility.component';
import { ResponsibilityService } from '../services/responsibility.service';
import { RESPONSIBILITIES } from '../test-data/responsibilities';
import { BannerMessage } from '../common/banner-message';
import { BannerMessageStatusEn, ErrorType } from '../common/enums';
import { SessionContext } from '../common/session-context';
import { Notification } from '../model/notification';
import { FilterSelection } from '../model/filter-selection';
import { TerritoryBranchContainer } from '../model/territory-branch-container';
import { FilterMatrix } from '../model/controller-model/filter-matrix';

@Component({
  selector: 'app-filter',
  templateUrl: './filter.component.html',
  styleUrls: ['./filter.component.css']
})
export class FilterComponent implements OnInit, OnChanges {

  user: User = null;
  bannerMessage: BannerMessage = new BannerMessage();
  bannerMessageStatus = BannerMessageStatusEn;

  @Input() shiftChangeProtocolConfirmed: boolean;
  @Input() shiftChangeProtocolOpened: boolean;
  @Input() filterExpanded: boolean;

  responsibilityContainerMatrix: TerritoryResponsibility[] = [];
  filterSelection: FilterSelection = new FilterSelection();
  filterMatrix: FilterMatrix = null;

  constructor(
    public sessionContext: SessionContext,
    private responsibilityService: ResponsibilityService,
    private messageService: MessageService
  ) { }

  ngOnChanges(changes: SimpleChanges) {
    if (changes['shiftChangeProtocolConfirmed'] !== undefined
      && changes['shiftChangeProtocolConfirmed'].currentValue !== undefined) {
      this.getSessionFilterMatrix();
    }

    if (changes['shiftChangeProtocolOpened'] !== undefined
      && changes['shiftChangeProtocolOpened'].currentValue !== undefined) {
      if (!changes['shiftChangeProtocolOpened'].currentValue) {
        this.initFilterMatrixWithDefaults();
      }
    }
  }

  ngOnInit() {
    this.user = this.sessionContext.getCurrUser();
  }

  getResponsiblity(responsibilityContainer: TerritoryResponsibility, branchName: string): Responsibility {    
    return responsibilityContainer.
      responsibilityList ? responsibilityContainer.responsibilityList.
        find(responsibility => responsibility.branchName === branchName) : null;
  }

  initFilterMatrixWithDefaults() {
    this.filterMatrix = this.sessionContext.getfilterMatrix();
    if (!this.filterMatrix) {

      this.responsibilityService.getAllResponsibilities().subscribe(resps => {

        this.responsibilityContainerMatrix = resps;
        for (const responsibilityContainer of this.responsibilityContainerMatrix) {
          for (const responsibility of responsibilityContainer.responsibilityList) {
            responsibility.isActive = responsibility.responsibleUser === this.user.username;
          }
        }
        this.responsibilitiesSelectionChanged();
      },
        error => {
          this.messageService.emitError('Filtermatrix', ErrorType.retrieve);
        });
    }
  }

  getSessionFilterMatrix() {
    this.filterMatrix = this.sessionContext.getfilterMatrix();
    if (this.filterMatrix) {
      const oldResponsibilityContainerMatrix = this.sessionContext.getfilterMatrix().responsibilityContainerMatrix;
      this.getUpdatedResponsibilities(oldResponsibilityContainerMatrix);
    }
  }

  findResponsibilityById(responsibilityContainerMatrix: TerritoryResponsibility[], respId: number): Responsibility {
    for (const responsibilityContainer of responsibilityContainerMatrix) {
      for (const responsibility of responsibilityContainer.responsibilityList) {
        if (responsibility.id === respId) {
          return responsibility;
        }
      }
    }
  }

  getUpdatedResponsibilities(oldResponsibilityContainerMatrix: TerritoryResponsibility[]) {
    let updatedResponsibilityContainerMatrix: TerritoryResponsibility[] = [];
    this.responsibilityService.getAllResponsibilities().subscribe(resps => {

      updatedResponsibilityContainerMatrix = resps;
      for (const responsibilityContainer of updatedResponsibilityContainerMatrix) {
        for (const responsibility of responsibilityContainer.responsibilityList) {
          const oldResp = this.findResponsibilityById(oldResponsibilityContainerMatrix, responsibility.id);
          responsibility.isActive = oldResp.isActive;
        }
      }

      this.responsibilityContainerMatrix = updatedResponsibilityContainerMatrix;
      const filterMatrix: FilterMatrix = new FilterMatrix(updatedResponsibilityContainerMatrix);
      this.messageService.matrixFilterChanged$.emit(filterMatrix.getNumFilterList());
    },
      error => {
        this.messageService.emitError('Filtermatrix', ErrorType.retrieve);
      }
    );
  }

  selectAllResponsibilities() {
    for (const responsibilityContainer of this.responsibilityContainerMatrix) {
      for (const responsibility of responsibilityContainer.responsibilityList) {
        responsibility.isActive = true;
      }
    }
    this.responsibilitiesSelectionChanged();
  }

  deselectAllResponsibilities() {
    for (const responsibilityContainer of this.responsibilityContainerMatrix) {
      for (const responsibility of responsibilityContainer.responsibilityList) {
        responsibility.isActive = false;
      }
    }
    this.responsibilitiesSelectionChanged();
  }
  
  responsibilitiesSelectionChanged() {
    const filterMatrix: FilterMatrix = new FilterMatrix(this.responsibilityContainerMatrix);
    this.sessionContext.setfilterMatrix(filterMatrix);
    this.messageService.matrixFilterChanged$.emit(filterMatrix.getNumFilterList());
  }

  mapUserName( shortUsr: string ) {
    const userMap = this.sessionContext.getUserMap();
    return userMap ? this.sessionContext.getUserMap().findAndRenderUser(shortUsr) : shortUsr;
  }

}