src/app/masterdata-management/components/standbygroup/standbygroup.component.ts - openk-usermodules/org.eclipse.openk-usermodules.standbyPlanning.frontend - Git at Google

 /********************************************************************************
  * Copyright © 2018 Mettenmeier GmbH.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
  *
  * SPDX-License-Identifier: EPL-2.0
  ********************************************************************************/
 import { Component, OnInit, OnDestroy, ViewChild, ElementRef, Injector } from '@angular/core';
 import { FormGroup, Validators } from '@angular/forms';
 import { NgbModalRef } from '@ng-bootstrap/ng-bootstrap';
 import { Subject, Subscription } from 'rxjs';
 import { Params } from '@angular/router';

 import { MasterdataService } from '@masterdata/services/masterdata.service';
 import { FormUtil } from '@shared/utils/form.util';
 import { StandbygroupObject } from '@shared/model/StandbygroupObject';
 import { ListUtil } from '@shared/utils/list.util';
 import { RegionObject } from '@shared/model/RegionObject';
 import { UserObject } from '@shared/model/UserObject';
 import { ValidityDialogComponent } from '@masterdata/selection-dialogs/validity-dialog/validity-dialog.component';
 import { StandbyDurationObject } from '@shared/model/StandbyDurationObject';
 import { BranchObject } from '@shared/model/BranchObject';
 import { AbstractFormComponent } from '@shared/abstract/abstract-form/abstract-form.component';
 import { FunctionObject } from '@shared/model/FunctionObject';
 import { InformationComponent } from '@shared/components/information/information.component';
 import { DateObject } from '@shared/model/DateObject';
 import { LoosingDataDialogComponent } from '@masterdata/selection-dialogs/loosing-data-dialog/loosing-data-dialog.component';
 import { ProtocolObject } from '@shared/model/ProtocolObject';
 import { ProtocolDialogComponent } from '@schedule/dialogs/protocol-dialog/protocol-dialog.component';
 import { CopyDialogComponent } from '@masterdata/selection-dialogs/copy-dialog/copy-dialog.component';
 import { AuthenticationService } from '@core/services/authentication.service';
 import { ProtocolMessageObject } from '@shared/model/ProtocolMessageObject';


 @Component({
   selector: 'ok-standbygroup',
   templateUrl: './standbygroup.component.html',
   styleUrls: ['./standbygroup.component.scss']
 })
 export class StandbygroupComponent extends AbstractFormComponent implements OnInit, OnDestroy {
   decisionModalRef: NgbModalRef;
   regionModalRef: NgbModalRef;
   copyModalRef: NgbModalRef;
   decision = new Subject<boolean>();
   modalAction = new Subject<string>();
   isModal = false;
   instanceId: number;
   addZero = FormUtil.addZero;

   @ViewChild('standbyDurationsModal')
   standbyDurationsModal: ElementRef;
   standbyDurationsModalRef: NgbModalRef;
   standbyDurationsForm: FormGroup;

   /**
    * Regions
    */
   sourceRegion: Array<any> = [];
   targetRegion: Array<any> = [];

   sourceColumnDefsRegion = [
     { headerName: 'Regionsname', field: 'regionName' }
   ];
   targetColumnDefsRegion = [
     { headerName: 'Regionsname', field: 'regionName' }
   ];

   /**
   * Users
   */
   sourceUser: Array<any> = [];
   targetUser: Array<any> = [];

   userModalRef: NgbModalRef;
   userModalWarningRef: NgbModalRef;

   sourceColumnDefsUser = [
     { headerName: 'Vorname', field: 'firstname' },
     { headerName: 'Nachname', field: 'lastname' },
     { headerName: 'OrganisationsName', field: 'organisationName' },
     { headerName: 'Funktionen', field: 'userHasUserFunctionStr' },
     { headerName: 'Regionen', field: 'userRegionStr' }
   ];
   targetColumnDefsUser = [
     { headerName: 'Position', field: 'position' },
     { headerName: 'Vorname', field: 'firstname' },
     { headerName: 'Nachname', field: 'lastname' },
     { headerName: 'OrganisationsName', field: 'organisationName' },
     { headerName: 'Funktionen', field: 'userHasUserFunctionStr' },
     { headerName: 'Regionen', field: 'userRegionStr' },
     {
       headerName: 'Gültig von', field: 'validFrom',
       filter: 'agDateColumnFilter',
       valueFormatter: ListUtil.formatDate,
       filterParams: {
         comparator: ListUtil.compareDates
       }
     },
     {
       headerName: 'Gültig bis',
       field: 'validTo',
       valueFormatter: ListUtil.formatDate,
       filterParams: {
         comparator: ListUtil.compareDates
       }
     }
   ];

   /**
   * Branches
   */
   sourceBranch: Array<BranchObject> = [];
   targetBranch: Array<BranchObject> = [];

   sourceColumnDefsBranch = [
     { headerName: 'Name', field: 'title' }
   ];
   targetColumnDefsBranch = [
     { headerName: 'Name', field: 'title' }
   ];

   /**
   * StandbyDurations
   */
   standbyDurations: Array<StandbyDurationObject>;
   modalProtocolRef: NgbModalRef;

   /**
    * Functions
    */
   sourceFunction: Array<FunctionObject> = [];
   targetFunction: Array<any> = [];
   function$: Subscription;
   functionModalRef: NgbModalRef;

   sourceColumnDefsFunction = [
     { headerName: 'Funktionsname', field: 'functionName' }
   ];
   targetColumnDefsFunction = [
     { headerName: 'Funktionsname', field: 'functionName' }
   ];

   /**
    * Calendar
    */
   sourceCalendar: Array<any> = [];
   targetCalendar: Array<any> = [];
   calender$: Subscription;

   sourceColumnDefsCalendar = [
     { headerName: 'Name', field: 'name' },
     {
       headerName: 'Datum', field: 'date',
       filter: 'agDateColumnFilter',
       valueFormatter: ListUtil.formatDate,
       filterParams: {
         comparator: ListUtil.compareDates
       }
     }
   ];
   targetColumnDefsCalendar = [
     { headerName: 'Name', field: 'name' },
     {
       headerName: 'Datum', field: 'date',
       filter: 'agDateColumnFilter',
       valueFormatter: ListUtil.formatDate,
       filterParams: {
         comparator: ListUtil.compareDates
       }
     }
   ];

   informationModalRef: NgbModalRef;
   param$: Subscription;
   standbygroup$: Subscription;
   region$: Subscription;
   user$: Subscription;
   branch$: Subscription;
   filterUser$: Subscription;
   constructor(
     public authService: AuthenticationService,
     private masterDataService: MasterdataService,
     private injector: Injector
   ) {
     super(injector);
   }

   ngOnInit() {
     this.createForm();
     this.param$ = this.route.params.subscribe((params: Params) => {
       this.instanceId = params['id'];
       if (this.instanceId) {
         this.standbygroup$ = this.masterDataService.getStandbygroup(this.instanceId).subscribe(
           standbygroupRes => {
             this.form.patchValue(standbygroupRes);
             this.targetRegion = standbygroupRes.lsRegions;
             this.targetUser = standbygroupRes.lsUserInStandbyGroups;
             this.targetBranch = standbygroupRes.lsBranches;
             this.targetFunction = standbygroupRes.lsUserFunction;
             this.standbyDurations = standbygroupRes.lsStandbyDurations;
             this.targetCalendar = standbygroupRes.lsIgnoredCalendarDays;
             this.getRegionList();
             this.getBranchList();
             this.getFunctionList();
             this.getCalendarList();
             this.filterUsersByStandbygroup();
           }
         );
       }
     });
   }

   createForm() {
     this.form = this.fb.group({
       id: '',
       title: ['', Validators.required],
       modificationDate: '',
       note: '',
       nextUserInNextCycle: false,
       extendStandbyTime: false,
       userFunctionId: ''
     });
   }

   getRegionList(): void {
     this.region$ = this.masterDataService.getRegionData().subscribe((regionRes: RegionObject[]) => {
       this.sourceRegion = FormUtil.getSubsetOfArray(regionRes, this.targetRegion, 'id', 'id');
     });
   }

   filterUsersByStandbygroup() {
     this.filterUser$ = this.masterDataService.filterUsersByStandbygroup(this.instanceId).subscribe((userRes: UserObject[]) => {
       this.sourceUser = userRes;
     });
   }

   getBranchList(): void {
     this.branch$ = this.masterDataService.getBranchDataSelection().subscribe((branchRes: BranchObject[]) => {
       this.sourceBranch = FormUtil.getSubsetOfArray(branchRes, this.targetBranch, 'id', 'id');
     });
   }

   getFunctionList(): void {
     this.function$ = this.masterDataService.getFunctionDataSelection().subscribe((functionRes: FunctionObject[]) => {
       this.sourceFunction = FormUtil.getSubsetOfArray(functionRes, this.targetFunction, 'functionId', 'functionId');
     });
   }

   getCalendarList(): void {
     this.calender$ = this.masterDataService.getCalendarData().subscribe((calenderRes: DateObject[]) => {
       this.sourceCalendar = FormUtil.getSubsetOfArray(calenderRes, this.targetCalendar, 'id', 'id');
     });
   }

   /**
   * Saves the current Form
   */
   saveStandbygroup(): boolean {
     if (FormUtil.validate(this.form)) {
       const standbygroupToSave = this.form.getRawValue();
       this.masterDataService.saveStandbygroup(standbygroupToSave).subscribe((res: StandbygroupObject) => {
         // neccessary due to canDeactivate guard
         FormUtil.markAsPristineAndUntouched(this.form);
         if (this.isModal) {
           this.router.navigate(['/stammdatenverwaltung/bereitschaftsgruppe', res.id]);
           this.modalAction.next('close');
         } else {
           this.router.navigate(['/stammdatenverwaltung/bereitschaftsgruppe']);
         }
       });
       return true;
     }
     return false;
   }

   /**
    * STANDBY DURATIONS
    */
   createStandbyDuration(): FormGroup {
     return this.fb.group({
       validDayFrom: ['', Validators.required],
       validDayTo: ['', Validators.required],
       validFrom: ['', Validators.required],
       validTo: ['', Validators.required],
       nextUserInNextDuration: false
     });
   }

   addDuration() {
     this.standbyDurationsForm = this.createStandbyDuration();
     this.standbyDurationsModalRef = this.modalService.open(this.standbyDurationsModal, { size: 'lg' });
   }

   removeDuration(index: number) {
     this.masterDataService.deleteStandbygroupDuration(this.instanceId, [this.standbyDurations[index]]).subscribe(
       (standbyDurationsRes: StandbyDurationObject[]) => {
         this.standbyDurations = standbyDurationsRes;
       }
     );
   }

   saveStandbyDuration() {
     if (FormUtil.validate(this.standbyDurationsForm)) {
       const standbygroupDurationToSave = this.standbyDurationsForm.getRawValue();
       standbygroupDurationToSave.standbyGroupId = this.instanceId;
       this.masterDataService.saveStandbygroupDuration(this.instanceId, [standbygroupDurationToSave]).subscribe(
         (standbydurationRes: ProtocolObject) => {
           // neccessary due to canDeactivate guard
           FormUtil.markAsPristineAndUntouched(this.standbyDurationsForm);
           this.standbyDurations = standbydurationRes.data;
           this.standbyDurationsModalRef.close();
         }
       );
       return true;
     }
     return false;
   }

   /**
    * MOVE FUNCTIONS REGION
    */

   moveToTargetRegion(dataToMove) {
     this.masterDataService.addStandbyGroupRegion(this.instanceId, dataToMove).subscribe((resRegionFunction: RegionObject[]) => {
       this.targetRegion = resRegionFunction;
       this.sourceRegion = FormUtil.getSubsetOfArray(this.sourceRegion, this.targetRegion, 'id', 'id');
       this.filterUsersByStandbygroup();

       this.messageService.add({ severity: 'success', summary: 'Regionen wurden gespeichert', detail: '' });
     });
   }

   moveToSourceRegion(dataToMove) {
     this.masterDataService.deleteStandbyGroupRegion(this.instanceId, dataToMove).subscribe((resRegionFunction: RegionObject[]) => {
       this.targetRegion = resRegionFunction;
       this.getRegionList();
       this.filterUsersByStandbygroup();

       this.messageService.add({ severity: 'success', summary: 'Regionen wurden gespeichert', detail: '' });
     });
   }

   /**
    * MOVE FUNCTIONS USER
    */

   moveToTargetUser(dataToMove, saveButtonLabel: string) {
     this.userModalRef = this.modalService.open(ValidityDialogComponent, { size: 'lg' });
     if (dataToMove.length === 1) {
       this.userModalRef.componentInstance.form.patchValue(
         {
           date: {
             validFrom: this.ngbDateParserFormatter.parse(dataToMove[0].validFrom),
             validTo: this.ngbDateParserFormatter.parse(dataToMove[0].validTo),
           },
           position: dataToMove[0].position
         }
       );
     }
     if (saveButtonLabel === 'Verschieben' || dataToMove.length > 1) {
       this.userModalRef.componentInstance.form.controls.position.disable();
     }
     this.userModalRef.componentInstance.saveButtonLabel = saveButtonLabel;
     this.userModalRef.componentInstance.decision.subscribe(resUserModal => {
       if (resUserModal) {
         for (let i = 0; i < dataToMove.length; i++) {
           dataToMove[i].validFrom = resUserModal.validFrom;
           dataToMove[i].validTo = resUserModal.validTo;
           if (saveButtonLabel === 'Verschieben') {
             dataToMove[i].userId = dataToMove[i].id;
             delete dataToMove[i].id;
           } else if (saveButtonLabel === 'Daten ändern' && dataToMove.length === 1) {
             dataToMove[i].position = resUserModal.position;
           }
           delete dataToMove[i].isCompany;
           delete dataToMove[i].notes;
           delete dataToMove[i].modificationDate;
         }
         this.masterDataService.addStandbyGroupUser(this.instanceId, dataToMove).subscribe((resUser: ProtocolObject) => {
           this.moveUserAndUpdate(resUser.data);
           if (saveButtonLabel === 'Daten ändern' && dataToMove.length === 1) {
             this.openProtocol(resUser);
           }
         });
       }
       this.userModalRef.close();
     });
   }

   copyUserToTarget(dataToMove) {
     for (let i = 0; i < dataToMove.length; i++) {
       const dateFrom = new Date(dataToMove[i].validFrom);
       const dateTo = new Date(dataToMove[i].validTo);
       dateFrom.setFullYear(dateFrom.getFullYear() + 1);
       dateTo.setFullYear(dateTo.getFullYear() + 1);
       dataToMove[i].validFrom = FormUtil.dateToISOString(dateFrom);
       dataToMove[i].validTo = FormUtil.dateToISOString(dateTo);
       delete dataToMove[i].position;
       delete dataToMove[i].id;
     }
     this.masterDataService.addStandbyGroupUser(this.instanceId, dataToMove).subscribe((resUser: ProtocolObject) => {
       this.moveUserAndUpdate(resUser.data);
     });
   }

   moveToSourceUser(dataToMove) {
     this.userModalWarningRef = this.modalService.open(LoosingDataDialogComponent);
     this.userModalWarningRef.componentInstance.decision.subscribe(resUserModal => {
       if (resUserModal) {
         this.masterDataService.deleteStandbyGroupUser(this.instanceId, dataToMove).subscribe((resUser: ProtocolObject) => {
           this.moveUserAndUpdate(resUser.data);
           this.openProtocol(resUser);
         });
       }
       this.userModalWarningRef.close();
     });
   }

   moveUserAndUpdate(resUser: UserObject[]) {
     this.targetUser = resUser;
     this.filterUsersByStandbygroup();

     this.messageService.add({ severity: 'success', summary: 'Bereitschaften wurden gespeichert', detail: '' });
   }

   /**
    * MOVE FUNCTIONS FUNCTION
    */

   moveToTargetFunction(dataToMove) {
     if (this.targetFunction.length > 0) {
       this.informationModalRef = this.modalService.open(InformationComponent);
     } else {
       this.masterDataService.addStandbygroupFunction(this.instanceId, dataToMove).subscribe((resFunctions: FunctionObject[]) => {
         this.targetFunction = resFunctions;
         this.sourceFunction = FormUtil.getSubsetOfArray(this.sourceFunction, this.targetFunction, 'functionId', 'functionId');
         this.filterUsersByStandbygroup();

         this.messageService.add({ severity: 'success', summary: 'Funktionen wurden gespeichert', detail: '' });
       });
     }
   }

   moveToSourceFunction(dataToMove) {
     this.masterDataService.deleteStandbygroupFunction(this.instanceId, dataToMove).subscribe((resFunctions: FunctionObject[]) => {
       this.targetFunction = resFunctions;
       this.getFunctionList();
       this.filterUsersByStandbygroup();

       this.messageService.add({ severity: 'success', summary: 'Funktionen wurden gespeichert', detail: '' });
     });
   }

   /**
   * MOVE FUNCTIONS BRANCHES
   */

   moveToTargetBranch(dataToMove) {
     this.masterDataService.addStandbyGroupBranch(this.instanceId, dataToMove).subscribe((resBranch: BranchObject[]) => {
       this.targetBranch = resBranch;
       this.sourceBranch = FormUtil.getSubsetOfArray(this.sourceBranch, this.targetBranch, 'id', 'id');

       this.messageService.add({ severity: 'success', summary: 'Sparten wurden gespeichert', detail: '' });
     });
   }

   moveToSourceBranch(dataToMove) {
     this.masterDataService.deleteStandbyGroupBranch(this.instanceId, dataToMove).subscribe((resBranch: BranchObject[]) => {
       this.targetBranch = resBranch;
       this.getBranchList();

       this.messageService.add({ severity: 'success', summary: 'Funktionen wurden gespeichert', detail: '' });
     });
   }

   /**
    * MOVE FUNCTIONS CALENDAR
    */

   moveToTargetCalendar(dataToMove) {
     this.masterDataService.addStandbygroupCalendar(this.instanceId, dataToMove).subscribe((resCalendar: DateObject[]) => {
       this.targetCalendar = resCalendar;
       this.sourceCalendar = FormUtil.getSubsetOfArray(this.sourceCalendar, this.targetCalendar, 'id', 'id');

       this.messageService.add({ severity: 'success', summary: 'Daten wurden gespeichert', detail: '' });
     });
   }

   moveToSourceCalendar(dataToMove) {
     this.masterDataService.deleteStandbygroupCalendar(this.instanceId, dataToMove).subscribe((resCalendar: DateObject[]) => {
       this.targetCalendar = resCalendar;
       this.getCalendarList();

       this.messageService.add({ severity: 'success', summary: 'Daten wurden gespeichert', detail: '' });
     });
   }

   /**
    * COPY STANDBYGROUP
    */
   openCopyDialog() {
     this.copyModalRef = this.modalService.open(CopyDialogComponent, { size: 'lg' });
     this.copyModalRef.componentInstance.decision.subscribe((dataToCopy) => {
       if (dataToCopy) {
         this.masterDataService.copyStandbygroup(this.instanceId, dataToCopy).subscribe((standbyGroup) => {
           this.router.navigate(['stammdatenverwaltung/bereitschaftsgruppe', standbyGroup.id]);
         });
       }
       this.copyModalRef.close();
     });
   }

   /**
    * UTIL METHODS
    */

   openProtocol(protocolObject: ProtocolObject) {
     if (protocolObject.lsMsg.length > 0) {
       this.modalProtocolRef = this.modalService.open(ProtocolDialogComponent, { windowClass: 'modal-xl', backdrop: 'static' });
       this.modalProtocolRef.componentInstance.protocol = protocolObject;
     }
   }

   close() {
     if (this.isModal) {
       this.modalAction.next('close');
     } else {
       this.router.navigate(['/stammdatenverwaltung/bereitschaftsgruppe']);
     }
   }

   public getWeekDay(weekDay: number) {
     const weekDays = {
       1: 'Montag',
       2: 'Dienstag',
       3: 'Mittwoch',
       4: 'Donnerstag',
       5: 'Freitag',
       6: 'Samstag',
       7: 'Sonntag'
     };

     return weekDays[weekDay];
   }

   ngOnDestroy() {
     if (this.param$) {
       this.param$.unsubscribe();
     }
     if (this.standbygroup$) {
       this.standbygroup$.unsubscribe();
     }
     if (this.region$) {
       this.region$.unsubscribe();
     }
     if (this.branch$) {
       this.branch$.unsubscribe();
     }
   }
 }
	/********************************************************************************
	* Copyright © 2018 Mettenmeier GmbH.
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0.
	*
	* SPDX-License-Identifier: EPL-2.0
	********************************************************************************/
	import { Component, OnInit, OnDestroy, ViewChild, ElementRef, Injector } from '@angular/core';
	import { FormGroup, Validators } from '@angular/forms';
	import { NgbModalRef } from '@ng-bootstrap/ng-bootstrap';
	import { Subject, Subscription } from 'rxjs';
	import { Params } from '@angular/router';

	import { MasterdataService } from '@masterdata/services/masterdata.service';
	import { FormUtil } from '@shared/utils/form.util';
	import { StandbygroupObject } from '@shared/model/StandbygroupObject';
	import { ListUtil } from '@shared/utils/list.util';
	import { RegionObject } from '@shared/model/RegionObject';
	import { UserObject } from '@shared/model/UserObject';
	import { ValidityDialogComponent } from '@masterdata/selection-dialogs/validity-dialog/validity-dialog.component';
	import { StandbyDurationObject } from '@shared/model/StandbyDurationObject';
	import { BranchObject } from '@shared/model/BranchObject';
	import { AbstractFormComponent } from '@shared/abstract/abstract-form/abstract-form.component';
	import { FunctionObject } from '@shared/model/FunctionObject';
	import { InformationComponent } from '@shared/components/information/information.component';
	import { DateObject } from '@shared/model/DateObject';
	import { LoosingDataDialogComponent } from '@masterdata/selection-dialogs/loosing-data-dialog/loosing-data-dialog.component';
	import { ProtocolObject } from '@shared/model/ProtocolObject';
	import { ProtocolDialogComponent } from '@schedule/dialogs/protocol-dialog/protocol-dialog.component';
	import { CopyDialogComponent } from '@masterdata/selection-dialogs/copy-dialog/copy-dialog.component';
	import { AuthenticationService } from '@core/services/authentication.service';
	import { ProtocolMessageObject } from '@shared/model/ProtocolMessageObject';


	@Component({
	selector: 'ok-standbygroup',
	templateUrl: './standbygroup.component.html',
	styleUrls: ['./standbygroup.component.scss']
	})
	export class StandbygroupComponent extends AbstractFormComponent implements OnInit, OnDestroy {
	decisionModalRef: NgbModalRef;
	regionModalRef: NgbModalRef;
	copyModalRef: NgbModalRef;
	decision = new Subject<boolean>();
	modalAction = new Subject<string>();
	isModal = false;
	instanceId: number;
	addZero = FormUtil.addZero;

	@ViewChild('standbyDurationsModal')
	standbyDurationsModal: ElementRef;
	standbyDurationsModalRef: NgbModalRef;
	standbyDurationsForm: FormGroup;

	/**
	* Regions
	*/
	sourceRegion: Array<any> = [];
	targetRegion: Array<any> = [];

	sourceColumnDefsRegion = [
	{ headerName: 'Regionsname', field: 'regionName' }
	];
	targetColumnDefsRegion = [
	{ headerName: 'Regionsname', field: 'regionName' }
	];

	/**
	* Users
	*/
	sourceUser: Array<any> = [];
	targetUser: Array<any> = [];

	userModalRef: NgbModalRef;
	userModalWarningRef: NgbModalRef;

	sourceColumnDefsUser = [
	{ headerName: 'Vorname', field: 'firstname' },
	{ headerName: 'Nachname', field: 'lastname' },
	{ headerName: 'OrganisationsName', field: 'organisationName' },
	{ headerName: 'Funktionen', field: 'userHasUserFunctionStr' },
	{ headerName: 'Regionen', field: 'userRegionStr' }
	];
	targetColumnDefsUser = [
	{ headerName: 'Position', field: 'position' },
	{ headerName: 'Vorname', field: 'firstname' },
	{ headerName: 'Nachname', field: 'lastname' },
	{ headerName: 'OrganisationsName', field: 'organisationName' },
	{ headerName: 'Funktionen', field: 'userHasUserFunctionStr' },
	{ headerName: 'Regionen', field: 'userRegionStr' },
	{
	headerName: 'Gültig von', field: 'validFrom',
	filter: 'agDateColumnFilter',
	valueFormatter: ListUtil.formatDate,
	filterParams: {
	comparator: ListUtil.compareDates
	}
	},
	{
	headerName: 'Gültig bis',
	field: 'validTo',
	valueFormatter: ListUtil.formatDate,
	filterParams: {
	comparator: ListUtil.compareDates
	}
	}
	];

	/**
	* Branches
	*/
	sourceBranch: Array<BranchObject> = [];
	targetBranch: Array<BranchObject> = [];

	sourceColumnDefsBranch = [
	{ headerName: 'Name', field: 'title' }
	];
	targetColumnDefsBranch = [
	{ headerName: 'Name', field: 'title' }
	];

	/**
	* StandbyDurations
	*/
	standbyDurations: Array<StandbyDurationObject>;
	modalProtocolRef: NgbModalRef;

	/**
	* Functions
	*/
	sourceFunction: Array<FunctionObject> = [];
	targetFunction: Array<any> = [];
	function$: Subscription;
	functionModalRef: NgbModalRef;

	sourceColumnDefsFunction = [
	{ headerName: 'Funktionsname', field: 'functionName' }
	];
	targetColumnDefsFunction = [
	{ headerName: 'Funktionsname', field: 'functionName' }
	];

	/**
	* Calendar
	*/
	sourceCalendar: Array<any> = [];
	targetCalendar: Array<any> = [];
	calender$: Subscription;

	sourceColumnDefsCalendar = [
	{ headerName: 'Name', field: 'name' },
	{
	headerName: 'Datum', field: 'date',
	filter: 'agDateColumnFilter',
	valueFormatter: ListUtil.formatDate,
	filterParams: {
	comparator: ListUtil.compareDates
	}
	}
	];
	targetColumnDefsCalendar = [
	{ headerName: 'Name', field: 'name' },
	{
	headerName: 'Datum', field: 'date',
	filter: 'agDateColumnFilter',
	valueFormatter: ListUtil.formatDate,
	filterParams: {
	comparator: ListUtil.compareDates
	}
	}
	];

	informationModalRef: NgbModalRef;
	param$: Subscription;
	standbygroup$: Subscription;
	region$: Subscription;
	user$: Subscription;
	branch$: Subscription;
	filterUser$: Subscription;
	constructor(
	public authService: AuthenticationService,
	private masterDataService: MasterdataService,
	private injector: Injector
	) {
	super(injector);
	}

	ngOnInit() {
	this.createForm();
	this.param$ = this.route.params.subscribe((params: Params) => {
	this.instanceId = params['id'];
	if (this.instanceId) {
	this.standbygroup$ = this.masterDataService.getStandbygroup(this.instanceId).subscribe(
	standbygroupRes => {
	this.form.patchValue(standbygroupRes);
	this.targetRegion = standbygroupRes.lsRegions;
	this.targetUser = standbygroupRes.lsUserInStandbyGroups;
	this.targetBranch = standbygroupRes.lsBranches;
	this.targetFunction = standbygroupRes.lsUserFunction;
	this.standbyDurations = standbygroupRes.lsStandbyDurations;
	this.targetCalendar = standbygroupRes.lsIgnoredCalendarDays;
	this.getRegionList();
	this.getBranchList();
	this.getFunctionList();
	this.getCalendarList();
	this.filterUsersByStandbygroup();
	}
	);
	}
	});
	}

	createForm() {
	this.form = this.fb.group({
	id: '',
	title: ['', Validators.required],
	modificationDate: '',
	note: '',
	nextUserInNextCycle: false,
	extendStandbyTime: false,
	userFunctionId: ''
	});
	}

	getRegionList(): void {
	this.region$ = this.masterDataService.getRegionData().subscribe((regionRes: RegionObject[]) => {
	this.sourceRegion = FormUtil.getSubsetOfArray(regionRes, this.targetRegion, 'id', 'id');
	});
	}

	filterUsersByStandbygroup() {
	this.filterUser$ = this.masterDataService.filterUsersByStandbygroup(this.instanceId).subscribe((userRes: UserObject[]) => {
	this.sourceUser = userRes;
	});
	}

	getBranchList(): void {
	this.branch$ = this.masterDataService.getBranchDataSelection().subscribe((branchRes: BranchObject[]) => {
	this.sourceBranch = FormUtil.getSubsetOfArray(branchRes, this.targetBranch, 'id', 'id');
	});
	}

	getFunctionList(): void {
	this.function$ = this.masterDataService.getFunctionDataSelection().subscribe((functionRes: FunctionObject[]) => {
	this.sourceFunction = FormUtil.getSubsetOfArray(functionRes, this.targetFunction, 'functionId', 'functionId');
	});
	}

	getCalendarList(): void {
	this.calender$ = this.masterDataService.getCalendarData().subscribe((calenderRes: DateObject[]) => {
	this.sourceCalendar = FormUtil.getSubsetOfArray(calenderRes, this.targetCalendar, 'id', 'id');
	});
	}

	/**
	* Saves the current Form
	*/
	saveStandbygroup(): boolean {
	if (FormUtil.validate(this.form)) {
	const standbygroupToSave = this.form.getRawValue();
	this.masterDataService.saveStandbygroup(standbygroupToSave).subscribe((res: StandbygroupObject) => {
	// neccessary due to canDeactivate guard
	FormUtil.markAsPristineAndUntouched(this.form);
	if (this.isModal) {
	this.router.navigate(['/stammdatenverwaltung/bereitschaftsgruppe', res.id]);
	this.modalAction.next('close');
	} else {
	this.router.navigate(['/stammdatenverwaltung/bereitschaftsgruppe']);
	}
	});
	return true;
	}
	return false;
	}

	/**
	* STANDBY DURATIONS
	*/
	createStandbyDuration(): FormGroup {
	return this.fb.group({
	validDayFrom: ['', Validators.required],
	validDayTo: ['', Validators.required],
	validFrom: ['', Validators.required],
	validTo: ['', Validators.required],
	nextUserInNextDuration: false
	});
	}

	addDuration() {
	this.standbyDurationsForm = this.createStandbyDuration();
	this.standbyDurationsModalRef = this.modalService.open(this.standbyDurationsModal, { size: 'lg' });
	}

	removeDuration(index: number) {
	this.masterDataService.deleteStandbygroupDuration(this.instanceId, [this.standbyDurations[index]]).subscribe(
	(standbyDurationsRes: StandbyDurationObject[]) => {
	this.standbyDurations = standbyDurationsRes;
	}
	);
	}

	saveStandbyDuration() {
	if (FormUtil.validate(this.standbyDurationsForm)) {
	const standbygroupDurationToSave = this.standbyDurationsForm.getRawValue();
	standbygroupDurationToSave.standbyGroupId = this.instanceId;
	this.masterDataService.saveStandbygroupDuration(this.instanceId, [standbygroupDurationToSave]).subscribe(
	(standbydurationRes: ProtocolObject) => {
	// neccessary due to canDeactivate guard
	FormUtil.markAsPristineAndUntouched(this.standbyDurationsForm);
	this.standbyDurations = standbydurationRes.data;
	this.standbyDurationsModalRef.close();
	}
	);
	return true;
	}
	return false;
	}

	/**
	* MOVE FUNCTIONS REGION
	*/

	moveToTargetRegion(dataToMove) {
	this.masterDataService.addStandbyGroupRegion(this.instanceId, dataToMove).subscribe((resRegionFunction: RegionObject[]) => {
	this.targetRegion = resRegionFunction;
	this.sourceRegion = FormUtil.getSubsetOfArray(this.sourceRegion, this.targetRegion, 'id', 'id');
	this.filterUsersByStandbygroup();

	this.messageService.add({ severity: 'success', summary: 'Regionen wurden gespeichert', detail: '' });
	});
	}

	moveToSourceRegion(dataToMove) {
	this.masterDataService.deleteStandbyGroupRegion(this.instanceId, dataToMove).subscribe((resRegionFunction: RegionObject[]) => {
	this.targetRegion = resRegionFunction;
	this.getRegionList();
	this.filterUsersByStandbygroup();

	this.messageService.add({ severity: 'success', summary: 'Regionen wurden gespeichert', detail: '' });
	});
	}

	/**
	* MOVE FUNCTIONS USER
	*/

	moveToTargetUser(dataToMove, saveButtonLabel: string) {
	this.userModalRef = this.modalService.open(ValidityDialogComponent, { size: 'lg' });
	if (dataToMove.length === 1) {
	this.userModalRef.componentInstance.form.patchValue(
	{
	date: {
	validFrom: this.ngbDateParserFormatter.parse(dataToMove[0].validFrom),
	validTo: this.ngbDateParserFormatter.parse(dataToMove[0].validTo),
	},
	position: dataToMove[0].position
	}
	);
	}
	if (saveButtonLabel === 'Verschieben' \|\| dataToMove.length > 1) {
	this.userModalRef.componentInstance.form.controls.position.disable();
	}
	this.userModalRef.componentInstance.saveButtonLabel = saveButtonLabel;
	this.userModalRef.componentInstance.decision.subscribe(resUserModal => {
	if (resUserModal) {
	for (let i = 0; i < dataToMove.length; i++) {
	dataToMove[i].validFrom = resUserModal.validFrom;
	dataToMove[i].validTo = resUserModal.validTo;
	if (saveButtonLabel === 'Verschieben') {
	dataToMove[i].userId = dataToMove[i].id;
	delete dataToMove[i].id;
	} else if (saveButtonLabel === 'Daten ändern' && dataToMove.length === 1) {
	dataToMove[i].position = resUserModal.position;
	}
	delete dataToMove[i].isCompany;
	delete dataToMove[i].notes;
	delete dataToMove[i].modificationDate;
	}
	this.masterDataService.addStandbyGroupUser(this.instanceId, dataToMove).subscribe((resUser: ProtocolObject) => {
	this.moveUserAndUpdate(resUser.data);
	if (saveButtonLabel === 'Daten ändern' && dataToMove.length === 1) {
	this.openProtocol(resUser);
	}
	});
	}
	this.userModalRef.close();
	});
	}

	copyUserToTarget(dataToMove) {
	for (let i = 0; i < dataToMove.length; i++) {
	const dateFrom = new Date(dataToMove[i].validFrom);
	const dateTo = new Date(dataToMove[i].validTo);
	dateFrom.setFullYear(dateFrom.getFullYear() + 1);
	dateTo.setFullYear(dateTo.getFullYear() + 1);
	dataToMove[i].validFrom = FormUtil.dateToISOString(dateFrom);
	dataToMove[i].validTo = FormUtil.dateToISOString(dateTo);
	delete dataToMove[i].position;
	delete dataToMove[i].id;
	}
	this.masterDataService.addStandbyGroupUser(this.instanceId, dataToMove).subscribe((resUser: ProtocolObject) => {
	this.moveUserAndUpdate(resUser.data);
	});
	}

	moveToSourceUser(dataToMove) {
	this.userModalWarningRef = this.modalService.open(LoosingDataDialogComponent);
	this.userModalWarningRef.componentInstance.decision.subscribe(resUserModal => {
	if (resUserModal) {
	this.masterDataService.deleteStandbyGroupUser(this.instanceId, dataToMove).subscribe((resUser: ProtocolObject) => {
	this.moveUserAndUpdate(resUser.data);
	this.openProtocol(resUser);
	});
	}
	this.userModalWarningRef.close();
	});
	}

	moveUserAndUpdate(resUser: UserObject[]) {
	this.targetUser = resUser;
	this.filterUsersByStandbygroup();

	this.messageService.add({ severity: 'success', summary: 'Bereitschaften wurden gespeichert', detail: '' });
	}

	/**
	* MOVE FUNCTIONS FUNCTION
	*/

	moveToTargetFunction(dataToMove) {
	if (this.targetFunction.length > 0) {
	this.informationModalRef = this.modalService.open(InformationComponent);
	} else {
	this.masterDataService.addStandbygroupFunction(this.instanceId, dataToMove).subscribe((resFunctions: FunctionObject[]) => {
	this.targetFunction = resFunctions;
	this.sourceFunction = FormUtil.getSubsetOfArray(this.sourceFunction, this.targetFunction, 'functionId', 'functionId');
	this.filterUsersByStandbygroup();

	this.messageService.add({ severity: 'success', summary: 'Funktionen wurden gespeichert', detail: '' });
	});
	}
	}

	moveToSourceFunction(dataToMove) {
	this.masterDataService.deleteStandbygroupFunction(this.instanceId, dataToMove).subscribe((resFunctions: FunctionObject[]) => {
	this.targetFunction = resFunctions;
	this.getFunctionList();
	this.filterUsersByStandbygroup();

	this.messageService.add({ severity: 'success', summary: 'Funktionen wurden gespeichert', detail: '' });
	});
	}

	/**
	* MOVE FUNCTIONS BRANCHES
	*/

	moveToTargetBranch(dataToMove) {
	this.masterDataService.addStandbyGroupBranch(this.instanceId, dataToMove).subscribe((resBranch: BranchObject[]) => {
	this.targetBranch = resBranch;
	this.sourceBranch = FormUtil.getSubsetOfArray(this.sourceBranch, this.targetBranch, 'id', 'id');

	this.messageService.add({ severity: 'success', summary: 'Sparten wurden gespeichert', detail: '' });
	});
	}

	moveToSourceBranch(dataToMove) {
	this.masterDataService.deleteStandbyGroupBranch(this.instanceId, dataToMove).subscribe((resBranch: BranchObject[]) => {
	this.targetBranch = resBranch;
	this.getBranchList();

	this.messageService.add({ severity: 'success', summary: 'Funktionen wurden gespeichert', detail: '' });
	});
	}

	/**
	* MOVE FUNCTIONS CALENDAR
	*/

	moveToTargetCalendar(dataToMove) {
	this.masterDataService.addStandbygroupCalendar(this.instanceId, dataToMove).subscribe((resCalendar: DateObject[]) => {
	this.targetCalendar = resCalendar;
	this.sourceCalendar = FormUtil.getSubsetOfArray(this.sourceCalendar, this.targetCalendar, 'id', 'id');

	this.messageService.add({ severity: 'success', summary: 'Daten wurden gespeichert', detail: '' });
	});
	}

	moveToSourceCalendar(dataToMove) {
	this.masterDataService.deleteStandbygroupCalendar(this.instanceId, dataToMove).subscribe((resCalendar: DateObject[]) => {
	this.targetCalendar = resCalendar;
	this.getCalendarList();

	this.messageService.add({ severity: 'success', summary: 'Daten wurden gespeichert', detail: '' });
	});
	}

	/**
	* COPY STANDBYGROUP
	*/
	openCopyDialog() {
	this.copyModalRef = this.modalService.open(CopyDialogComponent, { size: 'lg' });
	this.copyModalRef.componentInstance.decision.subscribe((dataToCopy) => {
	if (dataToCopy) {
	this.masterDataService.copyStandbygroup(this.instanceId, dataToCopy).subscribe((standbyGroup) => {
	this.router.navigate(['stammdatenverwaltung/bereitschaftsgruppe', standbyGroup.id]);
	});
	}
	this.copyModalRef.close();
	});
	}

	/**
	* UTIL METHODS
	*/

	openProtocol(protocolObject: ProtocolObject) {
	if (protocolObject.lsMsg.length > 0) {
	this.modalProtocolRef = this.modalService.open(ProtocolDialogComponent, { windowClass: 'modal-xl', backdrop: 'static' });
	this.modalProtocolRef.componentInstance.protocol = protocolObject;
	}
	}

	close() {
	if (this.isModal) {
	this.modalAction.next('close');
	} else {
	this.router.navigate(['/stammdatenverwaltung/bereitschaftsgruppe']);
	}
	}

	public getWeekDay(weekDay: number) {
	const weekDays = {
	1: 'Montag',
	2: 'Dienstag',
	3: 'Mittwoch',
	4: 'Donnerstag',
	5: 'Freitag',
	6: 'Samstag',
	7: 'Sonntag'
	};

	return weekDays[weekDay];
	}

	ngOnDestroy() {
	if (this.param$) {
	this.param$.unsubscribe();
	}
	if (this.standbygroup$) {
	this.standbygroup$.unsubscribe();
	}
	if (this.region$) {
	this.region$.unsubscribe();
	}
	if (this.branch$) {
	this.branch$.unsubscribe();
	}
	}
	}