D-Net

import { AuthService } from 'src/app/shared/services/auth.service';

import { USER_RIGHTS } from './../../../../shared/enums/USER_RIGHTS.enum';

import { CreateVerificationRuleFormValue } from './../../forms/verification-rule-form/create-verification-rule-form-value.interface';

import { VerificationRule } from './../../../../shared/models/verification-rule.interface';

import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';

import { ConfirmationService, LazyLoadEvent } from 'primeng/api';

import { VerificationRulesService } from 'src/app/shared/services/administration/verification-rules.service';

import { Page } from '../../../../shared/models/paging/page.interface';

import { TranslateService } from '@ngx-translate/core';

import { NotificationsHandlingService } from 'src/app/shared/services/notifications-handling/notifications-handling.service';

import { environment } from 'src/environments/environment';

@Component({

  selector: 'app-verification-rules-search-results',

  templateUrl: './verification-rules-search-results.component.html',

  styleUrls: ['./verification-rules-search-results.component.scss']

})

export class VerificationRulesSearchResultsComponent implements OnInit {

  @Output() paginationEvent = new EventEmitter<{ page: number, offset: number }>(true); // TODO: Use interface.

  @Output() valueChange = new EventEmitter<any>();

  @Input() loading: boolean;

  @Input() set searchResultsPage(results: Page<VerificationRule>) {

    // This setter may be called on page setup without arguments.

    if (!results) {

      return;

    }

    this._searchResultsPage = results;

    this.totalRecords = results.totalElements;

  }

  // tslint:disable-next-line:variable-name

  _searchResultsPage: Page<VerificationRule>;

  totalRecords: number;

  rows = 10;

  header: string;

  selectedValues: string[] = ['Enabled'];

  displayEditVerificationRuleDialog: boolean;

  verificationRuleToEdit: VerificationRule;

  constructor(

    private verificationRulesService: VerificationRulesService,

    private authService: AuthService,

    private translate: TranslateService,

    private confirmationService: ConfirmationService,

    private notificationHandling: NotificationsHandlingService

  ) { }

  ngOnInit(): void {

  }

  onLazyLoad(event: LazyLoadEvent): void {

    const pageToRequest = Math.floor(event.first / event.rows);

    const pageSize = event.rows;

    this.paginationEvent.emit({ page: pageToRequest, offset: pageSize });

  }

  edit(verificationRule: VerificationRule): void {

    this.verificationRuleToEdit = verificationRule;

    this.header = this.translate.instant('EDIT-RULE');

    this.displayEditVerificationRuleDialog = true;

  }

  cancelEditVerificationRule(): void {

    this.displayEditVerificationRuleDialog = false;

    this.verificationRuleToEdit = null;

  }

  delete(verificationRule: VerificationRule): void {

    this.confirmationService.confirm({

      accept: () => {

        this.verificationRulesService.delete(verificationRule.id).subscribe(

          (success) => {

            this.valueChange.emit(success);

            this.notificationHandling.showDeleteVerificationSuccess();

          },

          (error) => console.error(error)

        );

        // Actual logic to perform a confirmation

      }, reject: () => {

      }

    });

  }

  changeStatus(verificationRule: VerificationRule): void {

    this.loading = true;

    // Reverse its status.

    const newStatus = verificationRule.verificationRuleStatus.trim().toLowerCase() === 'enabled' ? 'Disabled' : 'Enabled';

    // First, transform the VerificationRule to a CreateVerificationRuleFormValue.

    const createRuleModel: CreateVerificationRuleFormValue = {

      id: verificationRule.id,

      confidenceLevelMinThreshold: verificationRule.confidenceLevelMinThreshold,

      clientId: verificationRule.client?.id,

      categoryId: verificationRule.template?.category?.id,

      subCategoryCode: verificationRule.template?.subCategoryCode,

      capturingVerification: verificationRule.capturingVerification,

      journalVerification: verificationRule.journalVerification,

      alteryxRoutineId: verificationRule.alteryxRoutineId,

      verificationRuleStatus: newStatus,

      template: verificationRule.template

    };

    // Update the rule and after we receive confirmation, also change its value in the table.

    this.verificationRulesService.updateVerificationRule(createRuleModel).subscribe(

      result => {

        this._searchResultsPage.data.find(rule => rule.id === verificationRule.id).verificationRuleStatus = newStatus

        this.valueChange.emit(result)

        this.notificationHandling.showUpdateVerificationRuleSuccess();

      },

      (error) => console.error(error),     // TODO: Handle this via a Messaging Service

      () => this.loading = false

    );

  }

  /*

   * Rights-check Methods

   */

  canEditRuleByUA(rule: VerificationRule): boolean {

    return this.authService.userHasRightForClient(USER_RIGHTS.B08, rule.client.id);

  }

  canDeleteRule(): boolean {

    return this.authService.userHasRightForClient(USER_RIGHTS.B05, environment.globalRightsClientID);

  }

  canEditRuleStatus(): boolean {

    return this.authService.userHasRightForClient(USER_RIGHTS.B06, environment.globalRightsClientID);

  }

  canEditRuleAll(): boolean {

    return this.authService.userHasRightForClient(USER_RIGHTS.B04, environment.globalRightsClientID);

  }

  passEvent(passEvent: any) {

    if (passEvent) {

      this.valueChange.emit(passEvent);

    }

  }

}