src/app/dialogs/shift-change/shift-change.component.ts

import { Component, Optional, OnInit } from '@angular/core';
import { MdDialogRef } from '@angular/material';

import { Responsibility } from '../../model/responsibility';
import { TerritoryResponsibility } from '../../model/territory-responsibility';
import { ResponsibilityService } from '../../services/responsibility.service';
import { SessionContext } from '../../common/session-context';
import { UserService } from '../../services/user.service';
import { BannerMessage } from '../../common/banner-message';
import { User } from '../../model/user';
import { BannerMessageStatusEn, ErrorType } from '../../common/enums';
import { MessageService, MessageDefines } from '../../services/message.service';

@Component({
  selector: 'app-shift-change',
  templateUrl: './shift-change.component.html',
  styleUrls: ['./shift-change.component.css']
})
export class ShiftChangeComponent implements OnInit {
  bannerMessageStatus = BannerMessageStatusEn;
  bannerMessage: BannerMessage = new BannerMessage();
  allUsersButLoggedIn: User[]= new Array<User>();
  allUsers: User[]= new Array<User>();
  preSelectedUsers: User[] = new Array<User>();
  responsibilityContainers: TerritoryResponsibility[]= new Array<TerritoryResponsibility>();
  selectAll = false;
  isChangingShift = false;
  noUserSelected = true;
  shiftChangeFormInValid = true;
  dropdownSettings = {};


  constructor(
    @Optional() public dialogRef: MdDialogRef<ShiftChangeComponent>,
    private responsibilityService: ResponsibilityService,
    private messageService: MessageService,
    private userService: UserService,
    private sessionContext: SessionContext) { }

  ngOnInit() {
    this.getUsers();
    this.getResponsibilities();
    this.dropdownSettings = {
      singleSelection: false,
      text: 'Vorauswahl Personen für Schichtübergabe',
      selectAllText: 'Alle Auswählen',
      unSelectAllText: 'Auswahl entfernen',
      enableSearchFilter: true,
      classes: 'custom-drop-down',
      badgeShowLimit: 2
    };
    this.checkIfPersonSelected();
  }

  getResponsibilities(): void {
    const self = this;
    this.responsibilityService.getResponsibilities().subscribe(resps => setUIRespValues(resps),
      error => {
        console.log(error);
        this.messageService.emitError('Schichtübergabe getResponsibilities', ErrorType.retrieve);
      }
    );
    function setUIRespValues(resps: TerritoryResponsibility[]) {
      for (const responsibilityContainer of resps) {
        for (const responsibility of responsibilityContainer.responsibilityList) {
          for (const user of self.allUsers) {
            if (!self.preSelectedUsers.find(preSelUser => preSelUser.username === user.username)
              && responsibility.newResponsibleUser === user.username) {
              self.preSelectedUsers.push(user);
            }
          }
        }
      }
      self.responsibilityContainers = resps;      
    }
  }

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

  getUsers() {
    const self = this;
    this.userService.getUsers().subscribe(resps => setUsers(resps),
      error => {
        console.log(error);
        this.messageService.emitError('Schichtübergabe getUsers', ErrorType.retrieve);
      }
    );
    function setUsers(_allUsers: User[]) {
      self.allUsers = _allUsers;
      self.allUsersButLoggedIn = [];
      const currLoggedInUser = self.sessionContext.getCurrUser();

      for (const user of _allUsers) {
        if (currLoggedInUser.id !== user.id) {
          self.allUsersButLoggedIn.push(user);
          user.itemName = user.name;
        }        
      }      
    }
  }

  cancelChange(): void {
    for (const responsibilityContainer of this.responsibilityContainers) {
      for (const responsibility of responsibilityContainer.responsibilityList) {
        responsibility.newResponsibleUser = '';
      }
    }
    this.shiftChange(false);
  }

  shiftChange(filter: boolean): void {
    const self = this;
    let filteredResponsibilityContainers = this.responsibilityContainers;
    if (filter) {
      filteredResponsibilityContainers = this.filterToValidResponsibilityContainerValues(this.responsibilityContainers);
    }
    

    this.responsibilityService.planResponsibilities(filteredResponsibilityContainers).subscribe(resps => setResp(resps),
      error => {
        this.messageService.emitError('Schichtübergabe', ErrorType.update);
        this.dialogRef.close();
      }
    );
    function setResp(respCs: TerritoryResponsibility[]) {
      if (respCs['ret'] && respCs['ret'] === 'OK') {
        self.dialogRef.close();
      } else {
        const text = 'Ihre Verantwortlichkeiten haben sich geändert. ' +
                'Bitte prüfen Sie Ihre Eingaben und versuchen Sie es erneut.';
                self.messageService.emitInfo(text);
        self.responsibilityContainers = respCs;
      }
    }
  }

  filterToValidResponsibilityContainerValues(_responsibilityContainers: TerritoryResponsibility[]): TerritoryResponsibility[] {
    const filteredRespContainers = new Array<TerritoryResponsibility>();
    const currUserName = this.sessionContext.getCurrUser().username;

    _responsibilityContainers.forEach(territoryResponsibility => {
      
      let tmpResponsibilityList = new Array<Responsibility>();      
      tmpResponsibilityList = territoryResponsibility.responsibilityList.filter(
        resp => (resp.responsibleUser === currUserName) 
              && (resp.newResponsibleUser !== '') 
              && (resp.newResponsibleUser !== currUserName));
      if (tmpResponsibilityList.length > 0) {
        const tmpTerritoryResponsibility = new TerritoryResponsibility();
        tmpTerritoryResponsibility.id = territoryResponsibility.id;
        tmpTerritoryResponsibility.gridTerritoryDescription = territoryResponsibility.gridTerritoryDescription;
        tmpTerritoryResponsibility.responsibilityList = tmpResponsibilityList;
        filteredRespContainers.push(tmpTerritoryResponsibility);
      }
    });          

    return filteredRespContainers;
  } 

  checkIfPersonSelected() {    
    this.shiftChangeFormInValid = true;
    for (const responsibilityContainer of this.responsibilityContainers) {
      for (const responsibility of responsibilityContainer.responsibilityList) {
        if (responsibility.newResponsibleUser !== '') {
          this.shiftChangeFormInValid = false;
          break;
        }
      }
    }        
  }
}