Hallo
wie wendet man @UserRoles eigentlich korrekt an?
Ich benutze eigentlich immer: verbergen wenn !@UserRoles="[Admin]" und das funktioniert auch.
Aber hier im Forum wird das immer im Zusammenhang mit @Contains oder @IsMember/@IsNotMember benutzt.
Welche Unterschiede bestehen hier? Kommt es darauf an, an welcher Stelle die Formel eingesetzt wird?
Funktioniert meine Formel an irgendeiner Stelle oder mit irgendeiner Konstellation nicht?
Gruß
Lizzy
Das hängt davon ab, was auf der rechten Seite des Gleichheitszeichens steht.
Wie Du sicher weisst, ist die Formel- Sprache sehr "bemerkenswert", wenn man zwei Listen vergleicht.
REGEL 1: Sind beide Listen gleichlang, dann wird jedes Element verglichen, und True zurückgegeben, wenn mindestens einer der Vergleiche True zurückliefert.
REGEL 2: Ist eine der Listen kürzer, wird das letzte Element der kürzeren Liste so lange wiederholt, bis beide gleich lang sind, dann kommt wieder Regel 1 zum Einsatz.
Das heisst:
@UserRoles = "[Admin]" übersetzt sich für einen Benutzer mit den Rollen "[AAA]" : "[Admin]" in folgende Matrix:
[AAA] = [Admin]
[Admin] = [Admin]
Wenn wir aber auf der rechten Seite auch mehr als einen Wert haben, wird es kompliziert:
@UserRoles = "[Admin]" : "[Administrator]"
wird zu
[AAA] = [Admin]
[Admin] = [Administrator]
was False zurückliefert (keines der Teilergebnisse ist True), obwohl man erwarten würde, dass da True zurückkommt, weil der Benutzer ja die Rolle Admin hat.
In so einem Fall is @IsMember / @IsNotMember definitiv die bessere Wahl.
@Contains ist für diesen Fall eigentlich grundsätzlich die falsche Wahl, weil es Substrings vergleicht, nicht ganze Elemente, führt aber bei Rollen im Normalfall zum richtigen Ergebnis, weil er keine Rollen gibt, die so aussehen: [Admin]istrator]
Hoffe, das Hilft.
Ach ja: Wichtig zu wissen ist in dem Zusammenhang dass:
@UserRoles != "[Admin]"
was ganz anderes ist als
!(@UserRoles = "[Admin]")
Das erste liefert True zurück, sobald es EIN Element gibt, das nicht [Admin] ist (also auch, wenn der User mehr Rollen als nur [Admin] hat), das zweite, wenn der User die Rolle [Admin] nicht hat...
Erklärung:
@UserRoles != "[Admin]" = [AAA] : [Admin] != [Admin]
Ergibt:
[AAA] != [Admin]
[Admin] != [Admin]
Erstes Statement ist True -> True
!(@UserRoles = "[Admin]") = !([AAA] : [Admin] = [Admin])
!(
[AAA] = [Admin]
[Admin] = [Admin])
Klammerstatement = True, wird negiert -> False
EDIT: Um das Verhalten von @IsMember mit einem einfachen Vergleich hinzubekommen, benutzt man den Permutations- Operator:
@UserRoles *= "[Admin]" : "[Administrator]" liefert wieder True, denn es übersetzt sich in:
[AAA] = [Admin]
[AAA] = [Administrator]
[Admin] = [Admin]
[Admin] = [Administrator]
und da haben wir ja wieder einen Treffer.
Wow, das nenn ich eine Erklärung - VIELEN DANK dafür!
Also, grundsätzlich stimmt dann meine Formel - !@UserRoles="[Admin]" - da ich bisher immer nur eine Rolle auf der rechten Seite hatte und bei Bedarf dann die Formel
!@UserRoles="[Admin]" & !@UserRoles="[DB-Admin]"
benutzt habe. Das müsste dann ja auch passen.
Den Permutations-Operator habe ich schon mal irgendwo gesehen, hab aber nicht gewusst, was er bedeutet.
Wenn ich das richtig verstehe, dann prüft
@UserRoles *= "[Admin]":"[Administrator]" alle nur möglichen Kombinationen ab und gibt True zurück, wenn eine davon zutrifft.
Im Gegensatz dazu, prüft @IsMember meines Wissens ja, ob ALLE Elemente der ersten Liste in der zweiten vorhanden sind.
Heisst in der Konsequenz:
- wenn User etwas darf, wenn er eine der abgefragten Rollen hat, dann nehme ich am besten den Permutations-Operator
- wenn User nur dann etwas darf, wenn er beide Rollen hat, dann brauche ich @IsMember("[Admin]":"[Administrator]";@UserRoles)
Sehe ich das richtig oder hast Du da Einwände?
Nochmal Danke für die Mühe, die Du Dir gemacht hast
Das hast Du korrekt erkannt.
