D-Net

import { RtaUser } from './../../../shared/models/rta-user.interface';

import { UserAccess } from './../../../shared/models/user-access.interface';

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

import { Right, Role } from './../../../shared/models/';

import { ConfirmationService } from 'primeng/api';

import { LazyLoadEvent } from 'primeng/api';

import { DialogService } from 'primeng/dynamicdialog';

import { CreateRoleComponent } from './create-role/create-role.component';

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

import { EditRoleComponent } from './edit-role/edit-role.component';

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

import { RolesService } from 'src/app/shared/services/roles-users-management/role.service';

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

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

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

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

@Component({

  selector: 'app-roles-management',

  templateUrl: './roles-management.component.html',

  styleUrls: ['./roles-management.component.scss']

})

export class RolesManagementComponent implements OnInit {

  loading = true;

  roles: Role[] = [];

  selectedRole: Role;

  totalRecords: number;

  rows = 10;

  users: RtaUser[];

  userAccessList: UserAccess[];

  event2: LazyLoadEvent;

  rights: Right[] = [];

  constructor(private confirmationService: ConfirmationService,

              private dialogService: DialogService, private translate: TranslateService, private auth: AuthService, private roleservice: RolesService,

              private notificationHandling: NotificationsHandlingService) { }

  ngOnInit(): void {

    if(this.auth.userRights.find(t=> t.client.id == environment.globalRightsClientID)?.rights){

      this.rights = this.auth.userRights.find(t=> t.client.id == environment.globalRightsClientID)?.rights;

    }

  }

  loadRoles(event: LazyLoadEvent): void {

    this.event2 = event;

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

    const pageSize = event.rows;

    this.loading = true;

    this.roleservice.getAllPaged(pageNumber, pageSize).subscribe((result: Page<Role>) => {

      this.roles = result.data;

      console.log(this.roles);

      this.totalRecords = result.totalElements;

      this.loading = false;

    },

      error => {

        this.loading = false;

      });

  }

  updateRoleStatus(role: Role): void {

    this.loading = true;

    this.roleservice.update(role).subscribe(result => {

      this.loading = false;

      this.loadRoles(this.event2);

      this.notificationHandling.showUpdateRoleStatusSuccess();

    },

      error => {

        this.loading = false;

      });

  }

  show(): void {

    const ref = this.dialogService.open(CreateRoleComponent, {

      header: this.translate.instant('CREATE_ROLE')

    });

    ref.onClose.subscribe((role: Role) => {

      if (role) {

        this.loadRoles(this.event2);

      }

  });

  }

  edit(selected: Role): void {

    const ref = this.dialogService.open(EditRoleComponent, {

      header: this.translate.instant('EDIT_ROLE_BUTTON'),

      //width: '70%',

      data: selected

    });

    ref.onClose.subscribe((role: Role) => {

      if (role) {

        this.loadRoles(this.event2);

      }

  });

  }

  editRoleIsDisabled(selectedRole: Role): boolean {

    if (selectedRole && !selectedRole.readOnly && USER_RIGHTS.G02.isGrantedToUser(this.rights)) {

      return false;

    } else {

      return true;

    }

  }

  createRoleIsDisabled(): boolean {

    if ( USER_RIGHTS.G01.isGrantedToUser(this.rights)) {

      return false;

    } else {

      return true;

    }

  }

  statusEnable(role: Role): boolean{

    if (USER_RIGHTS.G02.isGrantedToUser(this.rights) && !role.readOnly  ) {

      return false;

    } else {

      return true;

    }

  }

  roleCanBeDeleted(role: Role): boolean{

    if (USER_RIGHTS.G02.isGrantedToUser(this.rights) && role.canBeDeleted) {

      return false;

    } else {

      return true;

    }

  }

  deleteRole(id: number): void {

    this.loading = true;

    this.confirmationService.confirm({

      accept: () => {

        this.roleservice.delete(id).subscribe(result => {

          console.log(result);

          this.loading = false;

          this.loadRoles(this.event2);

          this.notificationHandling.showDeleteRoleSuccess();

        },

          error => {

            console.log('error');

            this.loading = false;

          });

        // Actual logic to perform a confirmation

      }, reject: () => {

        this.loading = false;

      }

    });

  }

  passEvent(passEvent : Role) {

    if(passEvent){

      this.loadRoles(this.event2);

    }

  }

}