286 lines
8.7 KiB
TypeScript
286 lines
8.7 KiB
TypeScript
// src/app/modules/users/profile/personal-profile.ts
|
|
import { Component, inject, OnInit, Output, EventEmitter, ChangeDetectorRef, OnDestroy } from '@angular/core';
|
|
import { CommonModule } from '@angular/common';
|
|
import { FormsModule } from '@angular/forms';
|
|
import { NgIcon } from '@ng-icons/core';
|
|
import { NgbAlertModule } from '@ng-bootstrap/ng-bootstrap';
|
|
import { Subject, takeUntil } from 'rxjs';
|
|
import { HubUsersService, UserRole, UpdateHubUserDto } from '../users/services/users.service';
|
|
import { RoleManagementService } from '@core/services/role-management.service';
|
|
import { AuthService } from '@core/services/auth.service';
|
|
|
|
@Component({
|
|
selector: 'app-my-profile',
|
|
standalone: true,
|
|
imports: [CommonModule, FormsModule, NgIcon, NgbAlertModule],
|
|
templateUrl: './profile.html',
|
|
styles: [`
|
|
.avatar-lg {
|
|
width: 80px;
|
|
height: 80px;
|
|
}
|
|
.fs-24 {
|
|
font-size: 24px;
|
|
}
|
|
`]
|
|
})
|
|
export class MyProfile implements OnInit, OnDestroy {
|
|
private usersService = inject(HubUsersService);
|
|
private roleService = inject(RoleManagementService);
|
|
private authService = inject(AuthService);
|
|
private cdRef = inject(ChangeDetectorRef);
|
|
private destroy$ = new Subject<void>();
|
|
|
|
@Output() back = new EventEmitter<void>();
|
|
@Output() openResetPasswordModal = new EventEmitter<string>();
|
|
|
|
user: any | null = null;
|
|
loading = false;
|
|
saving = false;
|
|
error = '';
|
|
success = '';
|
|
|
|
// Gestion des permissions (toujours true pour le profil personnel)
|
|
currentUserRole: UserRole | null = null;
|
|
canEditUsers = true; // Toujours vrai pour son propre profil
|
|
canManageRoles = false; // Jamais vrai pour le profil personnel
|
|
canDeleteUsers = false; // Jamais vrai pour le profil personnel
|
|
|
|
// Édition
|
|
isEditing = false;
|
|
editedUser: UpdateHubUserDto = {};
|
|
|
|
// Gestion des rôles (simplifiée pour profil personnel)
|
|
availableRoles: { value: UserRole; label: string; description: string }[] = [];
|
|
updatingRoles = false;
|
|
|
|
ngOnInit() {
|
|
this.initializeUserPermissions();
|
|
this.loadAvailableRoles();
|
|
this.loadUserProfile();
|
|
}
|
|
|
|
ngOnDestroy(): void {
|
|
this.destroy$.next();
|
|
this.destroy$.complete();
|
|
}
|
|
|
|
/**
|
|
* Initialise les permissions de l'utilisateur courant
|
|
*/
|
|
private initializeUserPermissions(): void {
|
|
this.authService.loadUserProfile()
|
|
.pipe(takeUntil(this.destroy$))
|
|
.subscribe({
|
|
next: (profile) => {
|
|
this.currentUserRole = profile?.roles?.[0] as UserRole || null;
|
|
// Pour le profil personnel, on peut toujours éditer son propre profil
|
|
this.canEditUsers = true;
|
|
this.canManageRoles = false; // On ne peut pas gérer les rôles de son propre profil
|
|
this.canDeleteUsers = false; // On ne peut pas se supprimer soi-même
|
|
},
|
|
error: (error) => {
|
|
console.error('Error loading user permissions:', error);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Charge les rôles disponibles (lecture seule pour profil personnel)
|
|
*/
|
|
private loadAvailableRoles(): void {
|
|
this.roleService.getAvailableRolesSimple()
|
|
.pipe(takeUntil(this.destroy$))
|
|
.subscribe({
|
|
next: (roles) => {
|
|
this.availableRoles = roles;
|
|
},
|
|
error: (error) => {
|
|
console.error('Error loading available roles:', error);
|
|
// Fallback
|
|
this.availableRoles = [
|
|
{ value: UserRole.DCB_ADMIN, label: 'DCB Admin', description: 'Administrateur système' },
|
|
{ value: UserRole.DCB_SUPPORT, label: 'DCB Support', description: 'Support technique' },
|
|
{ value: UserRole.DCB_PARTNER, label: 'DCB Partner', description: 'Partenaire commercial' }
|
|
];
|
|
}
|
|
});
|
|
}
|
|
|
|
loadUserProfile() {
|
|
this.loading = true;
|
|
this.error = '';
|
|
|
|
this.usersService.getUserById(this.user.id)
|
|
.pipe(takeUntil(this.destroy$))
|
|
.subscribe({
|
|
next: (user) => {
|
|
this.user = user;
|
|
this.loading = false;
|
|
this.cdRef.detectChanges();
|
|
},
|
|
error: (error) => {
|
|
this.error = 'Erreur lors du chargement de votre profil';
|
|
this.loading = false;
|
|
this.cdRef.detectChanges();
|
|
console.error('Error loading user profile:', error);
|
|
}
|
|
});
|
|
}
|
|
|
|
startEditing() {
|
|
// Pas de vérification de permission pour le profil personnel
|
|
this.isEditing = true;
|
|
this.editedUser = {
|
|
firstName: this.user?.firstName,
|
|
lastName: this.user?.lastName,
|
|
email: this.user?.email
|
|
// On ne permet pas de modifier 'enabled' sur son propre profil
|
|
};
|
|
this.cdRef.detectChanges();
|
|
}
|
|
|
|
cancelEditing() {
|
|
this.isEditing = false;
|
|
this.editedUser = {};
|
|
this.error = '';
|
|
this.success = '';
|
|
this.cdRef.detectChanges();
|
|
}
|
|
|
|
saveProfile() {
|
|
if (!this.user) return;
|
|
|
|
this.saving = true;
|
|
this.error = '';
|
|
this.success = '';
|
|
|
|
this.usersService.updateUser(this.user.id, this.editedUser)
|
|
.pipe(takeUntil(this.destroy$))
|
|
.subscribe({
|
|
next: (updatedUser) => {
|
|
this.user = updatedUser;
|
|
this.isEditing = false;
|
|
this.saving = false;
|
|
this.success = 'Profil mis à jour avec succès';
|
|
this.editedUser = {};
|
|
this.cdRef.detectChanges();
|
|
},
|
|
error: (error) => {
|
|
this.error = this.getErrorMessage(error);
|
|
this.saving = false;
|
|
this.cdRef.detectChanges();
|
|
}
|
|
});
|
|
}
|
|
|
|
// Gestion des rôles - désactivée pour profil personnel
|
|
updateUserRole(newRole: UserRole) {
|
|
// Non autorisé pour le profil personnel
|
|
this.error = 'Vous ne pouvez pas modifier votre propre rôle';
|
|
this.cdRef.detectChanges();
|
|
}
|
|
|
|
// Gestion du statut - désactivée pour profil personnel
|
|
enableUser() {
|
|
// Non autorisé pour le profil personnel
|
|
this.error = 'Vous ne pouvez pas vous activer/désactiver vous-même';
|
|
this.cdRef.detectChanges();
|
|
}
|
|
|
|
disableUser() {
|
|
// Non autorisé pour le profil personnel
|
|
this.error = 'Vous ne pouvez pas vous activer/désactiver vous-même';
|
|
this.cdRef.detectChanges();
|
|
}
|
|
|
|
// Réinitialisation du mot de passe
|
|
resetPassword() {
|
|
if (this.user) {
|
|
this.openResetPasswordModal.emit(this.user.id);
|
|
}
|
|
}
|
|
|
|
// Gestion des erreurs - même méthode que le premier composant
|
|
private getErrorMessage(error: any): string {
|
|
if (error.error?.message) {
|
|
return error.error.message;
|
|
}
|
|
if (error.status === 403) {
|
|
return 'Vous n\'avez pas les permissions nécessaires pour cette action';
|
|
}
|
|
if (error.status === 404) {
|
|
return 'Utilisateur non trouvé';
|
|
}
|
|
if (error.status === 400) {
|
|
return 'Données invalides';
|
|
}
|
|
return 'Une erreur est survenue. Veuillez réessayer.';
|
|
}
|
|
|
|
// Utilitaires d'affichage - mêmes méthodes que le premier composant
|
|
getStatusBadgeClass(): string {
|
|
if (!this.user) return 'badge bg-secondary';
|
|
if (!this.user.enabled) return 'badge bg-danger';
|
|
if (!this.user.emailVerified) return 'badge bg-warning';
|
|
return 'badge bg-success';
|
|
}
|
|
|
|
getStatusText(): string {
|
|
if (!this.user) return 'Inconnu';
|
|
if (!this.user.enabled) return 'Désactivé';
|
|
if (!this.user.emailVerified) return 'Email non vérifié';
|
|
return 'Actif';
|
|
}
|
|
|
|
formatTimestamp(timestamp: number): string {
|
|
if (!timestamp) return 'Non disponible';
|
|
return new Date(timestamp).toLocaleDateString('fr-FR', {
|
|
year: 'numeric',
|
|
month: 'long',
|
|
day: 'numeric',
|
|
hour: '2-digit',
|
|
minute: '2-digit'
|
|
});
|
|
}
|
|
|
|
getUserInitials(): string {
|
|
if (!this.user) return 'U';
|
|
return (this.user.firstName?.charAt(0) || '') + (this.user.lastName?.charAt(0) || '') || 'U';
|
|
}
|
|
|
|
getUserDisplayName(): string {
|
|
if (!this.user) return 'Utilisateur';
|
|
if (this.user.firstName && this.user.lastName) {
|
|
return `${this.user.firstName} ${this.user.lastName}`;
|
|
}
|
|
return this.user.username;
|
|
}
|
|
|
|
getRoleBadgeClass(role: UserRole): string {
|
|
return this.roleService.getRoleBadgeClass(role);
|
|
}
|
|
|
|
getRoleLabel(role: UserRole): string {
|
|
return this.roleService.getRoleLabel(role);
|
|
}
|
|
|
|
getRoleIcon(role: UserRole): string {
|
|
return this.roleService.getRoleIcon(role);
|
|
}
|
|
|
|
getRoleDescription(role: UserRole): string {
|
|
const roleInfo = this.availableRoles.find(r => r.value === role);
|
|
return roleInfo?.description || 'Description non disponible';
|
|
}
|
|
|
|
// Vérification des permissions pour les actions - toujours false pour les actions sensibles
|
|
canAssignRole(targetRole: UserRole): boolean {
|
|
return false; // Jamais autorisé pour le profil personnel
|
|
}
|
|
|
|
// Vérifie si c'est le profil de l'utilisateur courant - toujours true
|
|
isCurrentUserProfile(): boolean {
|
|
return true; // Toujours vrai pour le profil personnel
|
|
}
|
|
} |