Samuele Locatelli
727 lines
25 KiB
C#
727 lines
25 KiB
C#
using MagMan.Core.Services;
|
|
using MagMan.Data.Admin;
|
|
using MagMan.Data.Admin.DbModels;
|
|
using MagMan.Data.Admin.Services;
|
|
using MagMan.Data.Tenant.DbModels;
|
|
using Microsoft.AspNetCore.Components;
|
|
using Microsoft.AspNetCore.Identity;
|
|
using Microsoft.Data.SqlClient;
|
|
using Microsoft.JSInterop;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Security.Claims;
|
|
|
|
namespace MagMan.UI.Components
|
|
{
|
|
public partial class UserMan : IDisposable
|
|
{
|
|
#region Public Methods
|
|
|
|
public List<string> ConvertClaim(List<System.Security.Claims.Claim> ClaimList)
|
|
{
|
|
List<string> answ = new List<string>();
|
|
var pUpd = Task.Run(async () =>
|
|
{
|
|
await refreshLists();
|
|
});
|
|
pUpd.Wait();
|
|
|
|
// ciclo sui claims
|
|
foreach (var claim in ClaimList)
|
|
{
|
|
string claimStr = claim.ToString();
|
|
// verifico che in OGNI claim ci siaun valore ammissibile...
|
|
if (claimStr.Contains(":"))
|
|
{
|
|
// splitto chiave/valore
|
|
var splitClaim = claimStr.Split(':');
|
|
switch (splitClaim[0])
|
|
{
|
|
case "CustomerID":
|
|
if (customList != null)
|
|
{
|
|
var plantRec = customList
|
|
.Where(x => $"{x.CustomerID}" == splitClaim[1].Trim())
|
|
.FirstOrDefault();
|
|
if (plantRec != null)
|
|
{
|
|
answ.Add($"{splitClaim[0]}: {plantRec.Name}");
|
|
}
|
|
else
|
|
{
|
|
answ.Add($"{claim}");
|
|
}
|
|
}
|
|
break;
|
|
|
|
#if false
|
|
case "SupplierId":
|
|
if (suppList != null)
|
|
{
|
|
var plantRec = suppList
|
|
.Where(x => x.SupplierId.ToString() == splitClaim[1].Trim())
|
|
.FirstOrDefault();
|
|
if (plantRec != null)
|
|
{
|
|
answ.Add($"{splitClaim[0]}: {plantRec.SupplierDesc}");
|
|
}
|
|
else
|
|
{
|
|
answ.Add($"{claim}");
|
|
}
|
|
}
|
|
break;
|
|
|
|
case "TransporterId":
|
|
if (transpList != null)
|
|
{
|
|
var plantRec = transpList
|
|
.Where(x => x.TransporterId.ToString() == splitClaim[1].Trim())
|
|
.FirstOrDefault();
|
|
if (plantRec != null)
|
|
{
|
|
answ.Add($"{splitClaim[0]}: {plantRec.TransporterDesc}");
|
|
}
|
|
else
|
|
{
|
|
answ.Add($"{claim}");
|
|
}
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
case "None":
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return answ;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
AppMService.EA_SearchUpdated -= AppMService_EA_SearchUpdated;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera elenco utenti
|
|
/// </summary>
|
|
public async Task GetUsers()
|
|
{
|
|
// clear any error messages
|
|
strError = "";
|
|
|
|
UsersAll = await MTService.UserDataGetFilt(currSearch);
|
|
|
|
// filtro visualizzazione x tipo SE richeisto
|
|
if (FiltUserRole != "0")
|
|
{
|
|
UsersAll = UsersAll.Where(x => x.Roles.Contains(FiltUserRole)).ToList();
|
|
}
|
|
totalCount = UsersAll.Count;
|
|
|
|
UsersList = UsersAll
|
|
.Skip(numRecord * (currPage - 1)).Take(numRecord)
|
|
.ToList();
|
|
}
|
|
|
|
public string ShowClaims(List<System.Security.Claims.Claim> ClaimList)
|
|
{
|
|
string answ = string.Join(",", ConvertClaim(ClaimList));
|
|
return answ;
|
|
}
|
|
|
|
public string ShowRoles(List<string> RoleList)
|
|
{
|
|
string answ = string.Join(",", RoleList);
|
|
return answ;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Properties
|
|
|
|
[Inject]
|
|
protected UserManager<IdentityUser> _UserManager { get; set; } = null!;
|
|
|
|
[Inject]
|
|
protected MessageService AppMService { get; set; } = null!;
|
|
|
|
protected List<CustomerModel>? customList { get; set; } = null;
|
|
|
|
[Inject]
|
|
protected MTAdminService MTService { get; set; } = null!;
|
|
|
|
protected int totalCount { get; set; } = 0;
|
|
|
|
#endregion Protected Properties
|
|
|
|
#region Protected Methods
|
|
|
|
protected void DoSelect(UserData? selItem)
|
|
{
|
|
#if false
|
|
if (selItem != null)
|
|
{
|
|
ProjDbId = selItem.ProjDbId;
|
|
}
|
|
else
|
|
{
|
|
ProjDbId = 0;
|
|
}
|
|
E_ProjSel.InvokeAsync(selItem);
|
|
#endif
|
|
}
|
|
|
|
protected override async Task OnInitializedAsync()
|
|
{
|
|
currSearch = "";
|
|
string rawConf = Configuration["OptConf:MultiRoleEnab"];
|
|
if (rawConf != null)
|
|
{
|
|
bool.TryParse(rawConf, out MultiRoleEnab);
|
|
}
|
|
rawConf = Configuration["OptConf:MultiClaimEnab"];
|
|
if (rawConf != null)
|
|
{
|
|
bool.TryParse(rawConf, out MultiClaimEnab);
|
|
}
|
|
AppMService.EA_SearchUpdated += AppMService_EA_SearchUpdated;
|
|
// lettura dati
|
|
await GetUsers();
|
|
}
|
|
|
|
protected async Task SetNumRec(int newNum)
|
|
{
|
|
numRecord = newNum;
|
|
currPage = 1;
|
|
await InvokeAsync(ReloadData);
|
|
}
|
|
|
|
protected async Task SetPage(int newNum)
|
|
{
|
|
currPage = newNum;
|
|
DoSelect(null);
|
|
await InvokeAsync(ReloadData);
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Private Fields
|
|
|
|
private const string ADMIN_ROLE = "SuperAdmin";
|
|
|
|
private const string STD_CLAIM = "None";
|
|
|
|
private const string STD_CLAIM_VAL = "0";
|
|
|
|
private const string UNDEF_ROLE = "Undef";
|
|
|
|
/// <summary>
|
|
/// Elenco CLAIMS da mostrare durante editing
|
|
/// </summary>
|
|
private List<string> ClaimsList = new List<string>() { STD_CLAIM, "CustomerID" };
|
|
|
|
//private List<string> ClaimsList = new List<string>() { STD_CLAIM, "CustomerID", "SupplierId", "TransporterId" };
|
|
private Dictionary<string, string> ClaimValList = new Dictionary<string, string>();
|
|
|
|
private string currSearch = "";
|
|
|
|
/// <summary>
|
|
/// Abilitazoine gestione CLAIM multipli
|
|
/// </summary>
|
|
private bool MultiClaimEnab = false;
|
|
|
|
/// <summary>
|
|
/// Abilitazoine gestione ROLES multipli
|
|
/// </summary>
|
|
private bool MultiRoleEnab = false;
|
|
|
|
/// <summary>
|
|
/// User corrente
|
|
/// </summary>
|
|
private IdentityUser objUser = new IdentityUser();
|
|
|
|
private string qrCodeVal = "";
|
|
|
|
/// <summary>
|
|
/// Elenco ROLES da mostrare in dropdown durante editing (1 solo? usare DB?!?)
|
|
/// </summary>
|
|
private List<string> RolesList = new List<string>() { "Undef", "User", "SuperUser", "Admin", "SuperAdmin" };
|
|
|
|
// To enable showing the Popup
|
|
private bool ShowPopup = false;
|
|
|
|
// To hold any possible errors
|
|
private string strError = "";
|
|
|
|
/// <summary>
|
|
/// Collezione utenti (totale)
|
|
/// </summary>
|
|
private List<UserData> UsersAll = new List<UserData>();
|
|
|
|
/// <summary>
|
|
/// Collezione utenti
|
|
/// </summary>
|
|
private List<UserData> UsersList = new List<UserData>();
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Properties
|
|
|
|
private string _CurrClaimType { get; set; } = "None";
|
|
private string _filtUserRole { get; set; } = "0";
|
|
|
|
[Inject]
|
|
private IConfiguration Configuration { get; set; } = null!;
|
|
|
|
private Claim CurrentUserClaim
|
|
{
|
|
get => new Claim(CurrentUserClaimType, CurrentUserClaimVal);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Claims attuali utente
|
|
/// </summary>
|
|
private List<ClaimRec> CurrentUserClaims { get; set; } = new List<ClaimRec>();
|
|
|
|
/// <summary>
|
|
/// Claim di default (Tipo)
|
|
/// </summary>
|
|
private string CurrentUserClaimType
|
|
{
|
|
get
|
|
{
|
|
return _CurrClaimType;
|
|
}
|
|
set
|
|
{
|
|
_CurrClaimType = value;
|
|
var pUpd = Task.Run(async () => await refreshClaimVal(value));
|
|
pUpd.Wait();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Claim di default (valore)
|
|
/// </summary>
|
|
private string CurrentUserClaimVal { get; set; } = "0";
|
|
|
|
/// <summary>
|
|
/// Ruolo di default (User!!!)
|
|
/// </summary>
|
|
private string CurrentUserRole { get; set; } = "User";
|
|
|
|
private int currPage { get; set; } = 1;
|
|
|
|
/// <summary>
|
|
/// Ruoli correnti utente
|
|
/// </summary>
|
|
private string[] CurrUserRoles { get; set; } = new string[] { "User" };
|
|
|
|
/// <summary>
|
|
/// Gestione filtraggio dati
|
|
/// </summary>
|
|
private string FiltUserRole
|
|
{
|
|
get
|
|
{
|
|
return _filtUserRole;
|
|
}
|
|
set
|
|
{
|
|
if (_filtUserRole != value)
|
|
{
|
|
_filtUserRole = value;
|
|
var pUpd = Task.Run(async () => await ReloadData());
|
|
pUpd.Wait();
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool isLoading { get; set; } = false;
|
|
|
|
private int numRecord { get; set; } = 10;
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Private Methods
|
|
|
|
private void AddNewUser()
|
|
{
|
|
// Make new user
|
|
objUser = new IdentityUser();
|
|
objUser.PasswordHash = "*****";
|
|
// Set Id to blank so we know it is a new record
|
|
objUser.Id = "";
|
|
// Open the Popup
|
|
ShowPopup = true;
|
|
}
|
|
|
|
private async void AppMService_EA_SearchUpdated()
|
|
{
|
|
currSearch = AppMService.SearchVal;
|
|
await ReloadData();
|
|
}
|
|
|
|
private async Task ClosePopup()
|
|
{
|
|
// Close the Popup
|
|
ShowPopup = false;
|
|
// Refresh Users
|
|
await GetUsers();
|
|
}
|
|
|
|
private async Task DeleteUser(IdentityUser _IdentityUser)
|
|
{
|
|
#if false
|
|
// Close the Popup
|
|
ShowPopup = false;
|
|
|
|
if (!await JSRuntime.InvokeAsync<bool>("confirm", "Sicuro di voler eliminare l'utente selezionato??"))
|
|
return;
|
|
|
|
// Get the user
|
|
var user = await _UserManager.FindByIdAsync(_IdentityUser.Id);
|
|
if (user != null)
|
|
{
|
|
// Delete the user
|
|
await _UserManager.DeleteAsync(user);
|
|
}
|
|
#endif
|
|
// Refresh Users
|
|
await GetUsers();
|
|
}
|
|
|
|
private void EditUser(IdentityUser _IdentityUser)
|
|
{
|
|
// selezione come current user
|
|
objUser = _IdentityUser;
|
|
var pUpd = Task.Run(async () =>
|
|
{
|
|
// Get the user
|
|
var user = await _UserManager.FindByIdAsync(objUser.Id);
|
|
if (user != null)
|
|
{
|
|
// salvo role
|
|
var rawRoles = await _UserManager.GetRolesAsync(user);
|
|
CurrUserRoles = rawRoles.ToArray();
|
|
if (!MultiRoleEnab)
|
|
{
|
|
if (CurrUserRoles != null)
|
|
{
|
|
CurrentUserRole = CurrUserRoles.FirstOrDefault();
|
|
}
|
|
else
|
|
{
|
|
CurrentUserRole = UNDEF_ROLE;
|
|
}
|
|
}
|
|
|
|
// salvo claim
|
|
var UserClaims = await _UserManager.GetClaimsAsync(user);
|
|
CurrentUserClaims.Clear();
|
|
if (UserClaims != null)
|
|
{
|
|
int idx = 1;
|
|
foreach (var item in UserClaims)
|
|
{
|
|
CurrentUserClaims.Add(new ClaimRec(item, idx++));
|
|
}
|
|
}
|
|
|
|
if (!MultiClaimEnab)
|
|
{
|
|
if (CurrentUserClaims != null && CurrentUserClaims.Count > 0)
|
|
{
|
|
var CurrentUserClaim = UserClaims.FirstOrDefault();
|
|
CurrentUserClaimType = CurrentUserClaim.Type;
|
|
CurrentUserClaimVal = CurrentUserClaim.Value;
|
|
}
|
|
else
|
|
{
|
|
CurrentUserClaimType = STD_CLAIM;
|
|
CurrentUserClaimVal = "0";
|
|
}
|
|
}
|
|
|
|
string baseUrl = Configuration["OptConf:BaseAddr"];
|
|
string baseAppPath = Configuration["OptConf:BaseAppPath"];
|
|
string redirPage = Configuration["OptConf:QrRedirPage"];
|
|
if (!string.IsNullOrEmpty(baseAppPath))
|
|
{
|
|
if (baseUrl.EndsWith("/"))
|
|
{
|
|
baseUrl = baseUrl.Substring(0, baseUrl.Length - 1);
|
|
}
|
|
baseUrl = $"{baseUrl}{baseAppPath}";
|
|
}
|
|
qrCodeVal = $"{baseUrl}Identity/Account/LogIn?uid={user.Id}&uem={user.Email}&pag={redirPage}";
|
|
}
|
|
});
|
|
pUpd.Wait();
|
|
// Open the Popup
|
|
ShowPopup = true;
|
|
}
|
|
|
|
private async Task refreshClaimVal(string newType)
|
|
{
|
|
// init vuoto
|
|
ClaimValList = new Dictionary<string, string>();
|
|
// aggiorno elenco ClaimValList
|
|
switch (newType)
|
|
{
|
|
case "CustomerID":
|
|
// elenco plant --> to dictionary!
|
|
var customList = await MTService.CustomerGetAll();
|
|
if (customList != null)
|
|
{
|
|
ClaimValList = customList
|
|
.ToDictionary(x => $"{x.CustomerID}", x => x.Name);
|
|
}
|
|
break;
|
|
|
|
#if false
|
|
case "SupplierId":
|
|
// elenco plant --> to dictionary!
|
|
var suppList = await DataService.SuppliersGetAll();
|
|
if (suppList != null)
|
|
{
|
|
ClaimValList = suppList
|
|
.ToDictionary(x => $"{x.SupplierId}", x => x.SupplierDesc);
|
|
}
|
|
break;
|
|
|
|
case "TransporterId":
|
|
// elenco plant --> to dictionary!
|
|
var transpList = await DataService.TransportersGetAll();
|
|
if (transpList != null)
|
|
{
|
|
ClaimValList = transpList
|
|
.ToDictionary(x => $"{x.TransporterId}", x => x.TransporterDesc);
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
case "None":
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
private async Task refreshLists()
|
|
{
|
|
// effettuo refresh valori cache plants/suppliers/transp
|
|
if (customList == null)
|
|
{
|
|
customList = await MTService.CustomerGetAll();
|
|
}
|
|
}
|
|
|
|
private async Task ReloadData()
|
|
{
|
|
isLoading = true;
|
|
await GetUsers();
|
|
isLoading = false;
|
|
}
|
|
|
|
private async Task SaveUser()
|
|
{
|
|
try
|
|
{
|
|
// Is this an existing user?
|
|
if (objUser.Id != "")
|
|
{
|
|
// Get the user
|
|
var user = await _UserManager.FindByIdAsync(objUser.Id);
|
|
// Update Email + check email
|
|
user.Email = objUser.Email;
|
|
user.EmailConfirmed = objUser.EmailConfirmed;
|
|
// Update the user
|
|
await _UserManager.UpdateAsync(user);
|
|
// Only update password if the current value is not the default value
|
|
if (objUser.PasswordHash != "*****")
|
|
{
|
|
var resetToken =
|
|
await _UserManager.GeneratePasswordResetTokenAsync(user);
|
|
var passworduser =
|
|
await _UserManager.ResetPasswordAsync(
|
|
user,
|
|
resetToken,
|
|
objUser.PasswordHash);
|
|
if (!passworduser.Succeeded)
|
|
{
|
|
if (passworduser.Errors.FirstOrDefault() != null)
|
|
{
|
|
strError =
|
|
passworduser
|
|
.Errors
|
|
.FirstOrDefault()
|
|
.Description;
|
|
}
|
|
else
|
|
{
|
|
strError = "Password error";
|
|
}
|
|
// Keep the popup opened
|
|
return;
|
|
}
|
|
}
|
|
// Gestione salvataggio ruoli... SE VARIATO...
|
|
var UserRoles = await _UserManager.GetRolesAsync(user);
|
|
if (!MultiRoleEnab)
|
|
{
|
|
if (UserRoles != null && UserRoles.Count > 0)
|
|
{
|
|
var oldRole = UserRoles.FirstOrDefault();
|
|
if (!CurrentUserRole.Equals(oldRole))
|
|
{
|
|
// recupero il ruolo attuale e lo rimuovo
|
|
await _UserManager.RemoveFromRoleAsync(user, oldRole);
|
|
}
|
|
// aggiungo il nuovo ruolo
|
|
await _UserManager.AddToRoleAsync(user, CurrentUserRole);
|
|
}
|
|
else
|
|
{
|
|
// aggiungo il nuovo ruolo
|
|
await _UserManager.AddToRoleAsync(user, CurrentUserRole);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// verifico ruoli costanti...
|
|
var listOk = UserRoles.Intersect(CurrUserRoles).ToList();
|
|
var list2del = UserRoles.Except(listOk).ToList();
|
|
var list2add = CurrUserRoles.Except(listOk).ToList();
|
|
// elimino
|
|
foreach (var item in list2del)
|
|
{
|
|
await _UserManager.RemoveFromRoleAsync(user, item);
|
|
}
|
|
// aggiungo
|
|
foreach (var item in list2add)
|
|
{
|
|
await _UserManager.AddToRoleAsync(user, item);
|
|
}
|
|
}
|
|
|
|
// gestione salvataggio Claims
|
|
var UserClaims = await _UserManager.GetClaimsAsync(user);
|
|
if (!MultiClaimEnab)
|
|
{
|
|
if (UserClaims != null && UserClaims.Count > 0)
|
|
{
|
|
var oldClaim = UserClaims.FirstOrDefault();
|
|
if (!oldClaim.Equals(CurrentUserClaim))
|
|
{
|
|
// recupero il ruolo attuale e lo rimuovo
|
|
await _UserManager.RemoveClaimAsync(user, oldClaim);
|
|
}
|
|
// aggiungo il nuovo ruolo
|
|
await _UserManager.AddClaimAsync(user, CurrentUserClaim);
|
|
}
|
|
else
|
|
{
|
|
// aggiungo il nuovo ruolo
|
|
await _UserManager.AddClaimAsync(user, CurrentUserClaim);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// elimino i vecchi claims non presenti nel nuovo...
|
|
var listClaimsMod = CurrentUserClaims.Select(x => new Claim(x.Type, x.Value)).ToList();
|
|
var listOk = UserClaims.Intersect(listClaimsMod).ToList();
|
|
var list2del = UserClaims.Except(listOk).ToList();
|
|
var list2add = listClaimsMod.Except(listOk).ToList();
|
|
// elimino
|
|
foreach (var item in list2del)
|
|
{
|
|
await _UserManager.RemoveClaimAsync(user, item);
|
|
}
|
|
// aggiungo
|
|
foreach (var item in list2add)
|
|
{
|
|
await _UserManager.AddClaimAsync(user, item);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Insert new user
|
|
var NewUser =
|
|
new IdentityUser
|
|
{
|
|
UserName = objUser.Email,
|
|
Email = objUser.Email
|
|
};
|
|
var CreateResult = await _UserManager.CreateAsync(NewUser, objUser.PasswordHash);
|
|
if (!CreateResult.Succeeded)
|
|
{
|
|
if (CreateResult
|
|
.Errors
|
|
.FirstOrDefault() != null)
|
|
{
|
|
strError =
|
|
CreateResult
|
|
.Errors
|
|
.FirstOrDefault()
|
|
.Description;
|
|
}
|
|
else
|
|
{
|
|
strError = "Create error";
|
|
}
|
|
// Keep the popup opened
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// aggiungo a ruolo undef
|
|
await _UserManager.AddToRoleAsync(NewUser, UNDEF_ROLE);
|
|
// aggiungo claim undef...
|
|
await _UserManager.AddClaimAsync(NewUser, CurrentUserClaim);
|
|
}
|
|
}
|
|
// Close the Popup
|
|
ShowPopup = false;
|
|
// refresh cache...
|
|
await MTService.ResetUserDataCache();
|
|
// Refresh Users
|
|
await GetUsers();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
strError = ex.GetBaseException().Message;
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
|
|
#if false
|
|
protected async Task AddClaim(string rawClaim)
|
|
{
|
|
// splitto ed aggiungo...
|
|
if (rawClaim.Contains(":"))
|
|
{
|
|
CurrentUserClaims.Add(rawClaim);
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
protected async Task RemClaim(string rawClaim)
|
|
{
|
|
// splitto ed aggiungo...
|
|
if (rawClaim.Contains(":"))
|
|
{
|
|
if (CurrentUserClaims.Contains(rawClaim))
|
|
{
|
|
CurrentUserClaims.Remove(rawClaim);
|
|
await InvokeAsync(StateHasChanged);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
} |