Wie kann ich aktuellen Rechte auf ein Dokument feststellen

[Hatschi]

Hallo.

ein Script soll ein Dokument ändern. Weil es aber Autorenfelder gibt, möchte ich vorher abfragen ob der aktuelle Anwender überhaupt das Recht hat das Dokument zu verändern.
Muss ich dafür das Autorenfeld auswerten?
Die Klassen NotesACL und Notesdatabase liefern mir laut Beschreibung nur die Rechte auf die Datenbank. Gibt es nicht etwas äquivalentes für das aktuelle Dokument und den aktuellen Anwender?

Für Hinweise bedanke ich mich,

Bernd

[ascabg]

Hallo,

Meines Wissens nach Nein.
Du wirst wohl das Autorenfeld auswerten muessen. (sofern nur ein Autorenfeld vorhanden ist)


Andreas

[Hatschi]

Schade das es von Notes aus keine Klasse gibt, die das elegant löst.

Danke für den Hinweis.

Bernd

[Peter Klett]

Nachdem Du die ACL ausgewertet, hast, brauchst Du die Autorenfelder des Dokuments nur dann zu bemühen, wenn der User Autor in der Datenbank ist. Ist er nur Leser, darf er kein Dokument ändern, ist er Editor oder mehr, darf er jedes Dokument ändern.

Ich finde es aber recht mühsam, so vorzugehen. Da Du die Gruppen auflösen musst, bei Autorenfeldern musst Du zusätzlich Wildcards (*) berücksichtigen. Um einen vernünftigen Vorschlag zu geben, müsste man mehr über die Anwendung wissen.

Läuft das Script im geöffneten Dokument? Dann würde ich die Schaltfläche nur im Bearbeiten-Modus anzeigen, oder in dem Script das Dokument in den Bearbeiten-Modus versetzen, ist es danach immer noch im Lese-Modus, darf der Benutzer es nicht bearbeiten -> Ende des Scripts.

In einer Ansicht ist es nicht elegant, erst das Dokument zu öffnen. Wenn es mehrere sind, ist es sowieso sinnfrei. Bei solchen Aktionen nutze ich gerne einen Agenten, der von einem User mit höheren Rechten unterzeichnet ist. Dieser Agent wird dann mit agent.RunOnServer vom Benutzer gestartet, nachdem irgendwo ein entsprechender Änderungsauftrag erstellt wurde.

Vielleicht willst Du auch was ganz anderes?

[klaussal]

Das liegt aber auch daran, dass ich ja eine Person in ein Autoren- oder Leserfeld eintragen kann,
dies aber nicht zwangsläufig auch in der ACL drin steht.
Der Zugriff auf ein Dokument ist ein Zusammenspiel von ACL und Autoren/Leserfeldern ( sofern vorhanden).

[Hatschi]

Hallo Peter,

auf Knopfdruck sollen ein oder mehrere Dokumente exportiert werden. Es sollen also sowohl markierte Dokumente aus einer Ansicht heraus exportiert werden, also auch einzeln für das geöffnete Dokument.
Anschließend wird das Zielsystem von Notes aus gestartet und die exportierten Daten werden übergeben. Wenn dann auf der Zielseite die Datenübernahme bestätigt wurden, soll das Zielsystem dies per COM in die Dokumente nach Notes als Kennung schreiben. Das funktioniert so weit auch alles mit meinen Manager-Rechten, aber wenn das auf die Allgemeinheit losgelassen wird, dann wird der Export noch funktionieren, aber die Rückmeldung vom Zielsystem wird auf die Nase fallen. Und deshalb möchte ich schon vor dem Export wissen, ob der User das Dokument ändern darf.
Die Anwender sind als Editoren in der ACL eingetragen. Und es gibt 4 Felder vom Typ Author.
RunOnServer würde nicht funktionieren, weil das zurückschreiben ja über COM erfolgt.

Da bleibt mir wohl nichts als die Autoren abzuklappern. Ich befürchte da aber auf Gruppen und Rollen zu stoßen . . .

Bernd

[Tode]

Erst mal: Wenn die User alle Editoren sind, dann brauchst Du Dich doch darum gar nicht kümmern, dann darf jeder jedes Dokument schreiben...

Wenn Du aber das Ding "sicher" haben willst (also mit Autoren), dann würde ich das mit "Rückmelde- Dokumenten" machen... Die werden von Deinem export erstellt und dann entweder als Antwortdokumente auf das Original- dokument angehängt (kann man im dok ja in einer embedded view oder über ein berechnet zur Anzeige Feld anzeigen lassen), oder aber per Serverbasiertem Agenten die Info aus den Rückmeldungen wieder in die Original- Dokumente zurückgeschrieben (Rückmeldedokumente dann löschen nach erfolgter verarbeitung)

Gruss
Tode

[Hatschi]

Hallo Torsten,

sehe ich die Rechte falsch?
Die Anwender sind als Editoren in der ACL aufgeführt. Die Dokumente haben Felder vom Typ Author. Deshalb darf jeder das Dokument lesen.
In eins von den Autorenfeldern ist der Ersteller eingetragen. Er darf damit sein Dokument auch bearbeiten. Die anderen sind darüber ausgesperrt.
Deine Idee mit eigenständigen Antwortdokumenten wäre mit weiterem Programmieraufwand (Ansichten und Agenten) möglich. Aber ein neues Dokument als Antwortdokument möchte ich ungern erstellen, weil ja lediglich ein Feld übergeben wird indem drin steht das die Daten übernommen wurden.

Der Aufwand müsste gar nicht erst betrieben werden, wenn ich eine Funktion hätte in der Art AutorenRechte(doc, session.username) as boolean. Ich werde mich einmal daran versuchen und gucken wie weit ich komme.

Bernd

[Peter Klett]

sehe ich die Rechte falsch?

Ja

Die Anwender sind als Editoren in der ACL aufgeführt.

Damit können sie JEDES Dokument in der Datenbank bearbeiten, das sie sehen können

Die Dokumente haben Felder vom Typ Author. Deshalb darf jeder das Dokument lesen.

Solange die Dokumente nur Autorenfelder haben, kann JEDER die Dokumente in der Datenbank lesen, der mindestens Lesezugriff auf die Datenbank hat. Um den Lesezugriff einzuschränken, brauchst Du Leserfelder

In eins von den Autorenfeldern ist der Ersteller eingetragen. Er darf damit sein Dokument auch bearbeiten. Die anderen sind darüber ausgesperrt.

Nein, als Editor in der ACL nicht (s.o.).

Du solltest Dich mit den Zugriffsmechanismen in Notes auseinandersetzen ...

[Hatschi]

Mit folgendem Rumpf möchte ich starten:
Function AutorenRechte (doc , AnwenderName As String) As Boolean
   'Diese Funktion liefert true zurück, wenn der Anwender Autorenrechte hat
   Dim Anwender As notesname
   Dim test As Variant
   
   Set Anwender=New notesname(Anwendername)
   
   'Alle Items nach Autorenfelder durchsuchen
   Forall feld In doc.items
      If feld.isAuthors Then
         'es wurde ein Autorenfeld gefunden, prüfen ob der Anwender in der Liste auftaucht
         
         
      End If
   End Forall
End Function


Im Debugger habe ich mir nun ein paar Feldinhalte der Autorenfelder anzeigen lassen und bin dabei auch auf Rollen gestossen. Das wird dann noch ein wenig Arbeit die aufzudröseln.

Bernd

[Peter Klett]

Das wird nicht reichen, habe ich aber schon oben erwähnt.

Der Benutzer kann in 100 Autorenfeldern stehen. Wenn er nur Leser in der Datenbank ist, nützt ihm das nichts.

Ist er Editor, kann er das Dokument auch bearbeiten, wenn er in keinem Autorenfeld steht. Du wirst wohl mit der ACL anfangen müssen ..

[Hatschi]

Hallo Peter,

es soll ja auch jeder die Dokumente sehen, aber nur seine eigenen und bestimmte andere bearbeiten dürfen.

Auf den Dokumenten gibt es nur Autorenfelder, aber keine Leserfelder. Tatsache ist aber das andere meine Dokumente nicht bearbeiten könnnen. Dann müsste ja da noch ein anderer Mechanismus greifen, damit das so funktioniert wie von mit geschildert.
Hmmm, da muss ich mir das Rechtesystem von Notes in der Tat einmal ansehen.


Bernd

[Tode]

Es ist definitiv so: Autorenfelder sind nur für Autoren gültig, Editoren kratzen die gar nicht... leserfelder brauchst Du für Dein Szenario keine, aber alle Deine User MÜSSEN Autor sein.

Der Rumpf is schon mal ok...

Trotzdem ist das ein Haufen Arbeit.

ich habe grade mal auf der Basis von Peters früherer Antwort was ausprobiert:

Wenn Du in der Datenbank Document Locking aktivierst (Du brauchst einen Admin- Server in der ACL),
dann kannst Du rausfinden, ob ein User ein Dokument bearbeiten darf oder nicht, indem Du versuchst das Dokument zu sperren. Also so:

On error goto ErrorLock
call doc.Lock(ses.UserName,False)
On error goto wohinauchimmerdeinerrorhandlingzeigt


Exit Sub
ErrorLock:
'- Vielleicht protokollieren, oder dem benutzer melden, dass da was schief geht
resume NextDoc '- falls Du die verarbeitung für andere Dokumente trotz des Fehlers fortfahren willst, NextDoc ist dann die Sprungmarke, wo Du Dir Dein nächstes doc holst, typischerweise vor einer Zeile wie:
set doc = dc.getNextDocument(doc)
oder
set doc = dc.GetNthDocument(i) (hoffentlich eher nicht)
oder
...

HTH
Tode

[Peter Klett]

Ja, nämlich, dass die Benutzer Autor in der ACL sind, und nicht Editor, wie von Dir geschrieben.

Falls sie trotz Editorrechten die Dokumente nicht in den Bearbeiten-Modus versetzen können, ist da ein separater Mechanismus eingebaut (mache ich auch gerne, schau mal in das Event QueryModeChange), der aber nicht dazu führt, dass die Benutzer per Aktion das Dokument nicht ändern könnten.

Das kannst Du ganz einfach testen, indem Du eine Schaltfläche baust, die ein Dokument verändert. Gibt es eine Fehlermeldung von Notes, ist der User nur Autor.

[Hatschi]

Hallo Torsten,

mit einem On error goto habe ich auch schon geliebäugelt. Ich schreibe einfach etwas in ein Dummyfeld und wenn es zu einem Fehler beim Speichern kommt, breche ich die Bearbeitung gesittet ab.
Das wäre eine quick and dirty Lösung. Muss ich mir noch überlegen ob ich die so verwende. Der elegantere Weg wäre natürlich eine Abfrage . . .


Hallo Peter,

danke für deine hartnäckigen Kommentare zu den Rechten! Ich muss mich verklickt/verguckt/verschrieben haben. Die Anwender sind auf der Datenbank tatsächlich als Autoren geführt, und nicht wie von mit beschrieben als Editoren. Entschuldigung für die unnötige Verwirrung. Trotzdem werde ich das als Aufhänger nehmen und mir die Rechte anzusehen.


Vielen Dank für eure Hilfe und für heute erst einmal einen schönen Feierabend.
Bernd

[koehlerbv]

Peter, ein Eingriff in QueryModeChange reicht da aber in keiner Weise aus.

Bernd:
Du kannst auch - solange es um die Dokument-Rechte des aktuellen Nutzers geht - auch die Inhalte der Authors-Items auslesen und vergleichen mit einem Evaluate ("@UserNamesList"). Wenn Du dabei einen Treffer erzielst, dann passen die Autorenrechte.
Und @UsernamesList löst auch nested groups auf.

HTH,
Bernhard

[Peter Klett]

Peter, ein Eingriff in QueryModeChange reicht da aber in keiner Weise aus.

Nö, aber wenn da nichts drin ist, wird es wohl keine eigene Steuerung geben.

[koehlerbv]

Jo, das ist wohl war, denn da muss *auch* was drin sein (wenn man nicht das offensichtlichste Loch haben will) 

Bernhard

[Hatschi]

Hallo Bernhard,

Dank euren Hinweisen mit @usernameslist bin ich nun zu folgendem Scriptcode gekommen:


Function AutorenRechte (doc ) As Boolean
   'Diese Funktion liefert true zurück, wenn der Anwender Autorenrechte hat
   
   'Array mit den Feldnamen vom Typ Authors, ist zwar nicht nötig, aber eine Hilfe beim debuggen
   Dim AutorenFeldNamen () As String    
   'Array mit den Inhalten der Autorenfelder
   Dim Autoren                                
   Dim UserNameslist As Variant
   Dim gefunden As Variant
   
   Redim AutorenFeldNamen (0)
   Redim Autoren (0)
   
   'Rückgabewert der Funktion auf False setzen
   AutorenRechte=False
   
   'Alle Items nach Autorenfelder durchsuchen
   Forall feld In doc.items
      If feld.isAuthors Then
         'es wurde ein Autorenfeld gefunden
         'den Feldnamen im Array merken
         AutorenFeldNamen ( Ubound (AutorenFeldNamen)) = feld.name
         Redim Preserve AutorenFeldNamen ( Ubound (AutorenFeldNamen) +1)         
         'den Inhalt im Array merken
         Autoren = Arrayappend(Autoren, feld.values)
      End If
   End Forall
   
   'Die aktuellen Userdaten holen
   UserNameslist = Evaluate("@usernameslist")
   
   'Weil ein leeres Element des Array zuviel erzeugt wird, hier den Eintrag entfernen
   Redim Preserve AutorenFeldNamen ( Ubound (AutorenFeldNamen) -1)   
   
   'Prüfen ob ein Eintrag aus der Usernamelist in den Autoren zu finden ist
   Forall test In UserNameslist
      gefunden=Arraygetindex (Autoren, test, 5 )
      If gefunden > 0 Then
         'es wurde ein Eintrag gefunden der die Autorenrechte belegt,
         AutorenRechte=True
         Exit Forall
      End If
   End Forall
   
End Function


Bernd

[marschul]

2 Anmerkungen:

Bei dem Array AutorenFeldNamen läufst du Gefahr, auf einen Fehler zu laufen, nämlich dann, wenn keine Autorenfelder vorhanden sind. Dann ist ubound = 0 und mit dem letzten Redim versuchst Du, es auf -1 zu setzen.
Besser wäre:
statt

AutorenFeldNamen ( Ubound (AutorenFeldNamen)) = feld.name
Redim Preserve AutorenFeldNamen ( Ubound (AutorenFeldNamen) +1)

Code

If AutorenFeldNamen(0) = "" Then
  AutorenFeldNamen(0) = feld.name
Else
  Redim Preserve AutorenFeldNamen(Ubound(AutorenFeldNamen) + 1)
  AutorenFeldNamen(Ubound(AutorenFeldNamen)) = feld.name
End If

Damit kann das spätere Redim um -1 weg.
Allerdings verwendest Du dieses Array anschließend gar nicht mehr, weshalb das alles überflüssig sein dürfte  
Bezüglich des verwendeten Arrays Autoren würde ich schreiben

Code

Autoren = Fulltrim(ArrayUnique(ArrayAppend(Autoren, feld.values)))

Das verhindert, dass leere Werte bzw. Werte mehrfach auftauchen.

Die Abfrage bezüglich 'gefunden' dürfte auch scheitern, wenn nicht gefunden, dann ist das Ergebnis nämlich nicht 0 sondern Null, also statt

If gefunden > 0...

Code

If Not IsNull(gefunden) Then...