/// <summary>
/// This method returns if the user is authorized for dataset from parameter to
/// at least minimal rights from parameter.
/// </summary>
/// <param name="rightsDictionary">Rights dictionary for validation</param>
/// <param name="datasetId">Id of dataset to check authorization for</param>
/// <param name="minimalRights">Minimal rights to be authorized</param>
/// <returns>True if rights is authorized, false otherwise.</returns>
public static bool IsAuthorized(Dictionary <long, RightsEnum> rightsDictionary, long datasetId, RightsEnum minimalRights)
{
if (rightsDictionary.Keys.Contains(datasetId))
{
return(rightsDictionary[datasetId] >= minimalRights);
}
Logger.LogToConsole($"Rights for dataset with id {datasetId} not in rightsDictionary.");
return(false);
}
public User(RightsEnum rights)
{
Rights = rights;
}
/// <summary>
/// Permet d'indiquer si l'utilisateur courant est autorisé à accéder à la fonction
/// </summary>
/// <returns></returns>
private static bool IsCurrentAuthorized(RightsEnum identifiantDroit)
{
return ServiceLocator.Current.GetInstance<IAccessLayer>().CurrentUser.IsAdministrator || ServiceLocator.Current.GetInstance<IAccessLayer>().IsAuthorizedFunction(identifiantDroit);
}
/// <summary>
/// This method returns if the user is authorized for dataset from parameter to
/// at least minimal rights from parameter.
/// </summary>
/// <param name="userModel">Model of user to get the rights from</param>
/// <param name="datasetId">Id of dataset to check authorization for</param>
/// <param name="minimalRights">Minimal rights to be authorized</param>
/// <returns>True if user is authorized, false otherwise.</returns>
public static bool IsAuthorized(UserModel userModel, long datasetId, RightsEnum minimalRights)
{
return(IsAuthorized(userModel.Rights.DataDictionary, datasetId, minimalRights));
}
private void OnUserChanged(RightsEnum rights)
{
UserHasSettRight = rights.HasFlag(RightsEnum.Settings);
UserHasStatisticRight = rights.HasFlag(RightsEnum.Statistic);
}
private void OnUserChanged(RightsEnum rights)
{
IsAdministrator = !rights.HasFlag(RightsEnum.ClientDiscount);
}
/// <summary>
/// Retrouve les droits réels de l'utilisateur pour la fonction
/// </summary>
/// <param name="identifiantDroit"></param>
/// <returns></returns>
public ValueRightsEnum ValueAuthorizedFunction(RightsEnum identifiantDroit)
{
if (CurrentUser.IsAdministrator)
{
return ValueRightsEnum.Tous;
}
var valueIdentifiantDroit = StringEnumHelper.GetStringValue(identifiantDroit);
if (_valuesRightDictionary.ContainsKey(valueIdentifiantDroit))
{
ValueRightsEnum value;
if (_valuesRightDictionary.TryGetValue(valueIdentifiantDroit, out value))
{
return value;
}
}
return ValueRightsEnum.Aucun;
}
/// <summary>
/// Permet de savoir si l'utilisateur est autorisé à utiliser cette fonction, récupére en même temps les droits pour l'utilisateur
/// </summary>
/// <param name="identifiantDroit"></param>
/// <param name="rights"></param>
/// <returns></returns>
public bool IsAuthorizedFunction(RightsEnum identifiantDroit, out ValueRightsEnum rights)
{
if (_currentUser == null)
{
rights = ValueRightsEnum.Aucun;
return false;
}
if (_currentUser.IsAdministrator)
{
rights = ValueRightsEnum.Tous;
return true;
}
var valueIdentifiantDroit = StringEnumHelper.GetStringValue(identifiantDroit);
var dts = _repositoryService.Where<SysDroits>(d => d.IdentifiantDroit == valueIdentifiantDroit);
if (dts.Any())
{
var firstDt = dts.First();
var droits = _repositoryService.Where<SysUtilisateurDroits>(d => d.DroitId == firstDt.Id).ToList();
if (droits.Any())
{
var isAuthorized = false;
var valuesDroit = 0;
//On regarde les droits de l'utilisateur
var droitsUser = droits.Where(d => d.UtilisateurId == _currentUser.Id);
if (droitsUser.Any())
{
valuesDroit = droitsUser.First().Value;
isAuthorized = (valuesDroit > 0) && ((ValueRightsEnum) valuesDroit != ValueRightsEnum.Bloque);
}
if (((ValueRightsEnum) valuesDroit != ValueRightsEnum.Bloque) && valuesDroit == 0)
{
//On regarde si l'utilisateur fait parti d'un groupe
if (_currentUser.Groupes != null && _currentUser.Groupes.Any())
{
foreach (var groupe in _currentUser.Groupes)
{
SysGroupe groupe1 = groupe;
var droitsGroup =
droits.Where(d => d.GroupeId == groupe1.Id);
if (droitsGroup.Any())
{
valuesDroit = droitsGroup.First().Value;
isAuthorized = valuesDroit > 0;
if (!isAuthorized)
{
//Si l'un des groupes ne posséde pas de droit pour, c'est cette valeur qui prend le pas sur les autres
break;
}
}
}
}
}
//On stocke les droits réels pour l'objet afin de facilement les retrouver par la suite
rights = GetDictionnaryValuesForRight(valuesDroit);
return isAuthorized;
}
}
rights = ValueRightsEnum.Aucun;
return false;
}
public void OnUserChanged(RightsEnum rights)
{
UserHasReadRight = rights.HasFlag(RightsEnum.Read);
UserHasWriteRight = rights.HasFlag(RightsEnum.Write);
}
public static void SetApplicationRole(RightsEnum rightsEnum)
{
string applicationRole = "";
switch (rightsEnum)
{
case RightsEnum.АРМБухгалтер:
applicationRole = "АРМ Бухгалтер";
break;
case RightsEnum.АРМПоставщикУслуг:
applicationRole = "АРМ Поставщик услуг";
break;
}
Mappers.UserMapper.SetApplicationRole(applicationRole);
}
public static bool IsMemberOf(RightsEnum right)
{
return Mappers.UserMapper.IsMemberOf(right, CurrentUser);
}
