Attachment 'source.html'
Download#pragma supplementation-page on
#pragma section-numbers on
#!wiki blue This text was written for a [[http://www.rrzn.uni-hannover.de/buecher.html?&no_cache=1&tx_rrznbuecher_pi1[showUid]=215|german python book]]. The idea was to give an advertice in learning python with examples of popular python projects. Two chapter of the book were about python learning and the last chapter describes first steps for three python projects. At last the publisher decided to drop the third chapter for several reasons. @copyright: 2007-2008 MoinMoin:ReimarBauer @license: GPL
#!wiki yellow . <<Hits>> times read
<<TableOfContents>>
MoinMoin (1.6) - Erweiterungen und Anpassungen (Reimar Bauer)
##der text der hier hin soll steckt noch im Buch
Einleitung fgfdg
|
qa |
d |
|
d |
d |
|
d |
d |
MoinMoin ist eine Wiki-Software, welche in Python geschrieben ist. Zur Drucklegung dieses Buches befindet sich die Version 1.7 kurz vor der Veröffentlichung -- auf der Homepage (http://moinmo.in) können Sie Aktuelles zum Entwicklungsstand erfahren. MoinMoin ist Freie Software (Open Source Software) unter der GNU General Public License. Diese Beschreibung setzt voraus, dass Sie die aktuelle Version dieser Software von der Homepage herunterladen.
Ein Wiki ist eine im World Wide Web verfügbare Seitensammlung, die von den Benutzern nicht nur gelesen, sondern auch in Echtzeit online geändert werden kann. Wie bei Hypertexten üblich, sind die einzelnen Seiten und Artikel eines Wikis durch Querverweise (Links) miteinander verbunden.
Ab der Version 1.6 enthält MoinMoin ein vorkonfiguriertes Wiki, das in Verbindung mit dem in der Python-Standardbibliothek enthaltenen Webserver gut für ein persönliches Wiki auf dem lokalem Desktop geeignet ist. Diese Kombination ermöglicht es ebenso, in einer Entwicklungsumgebung (z.B. Eclipse/PyDev), komfortabel zu debuggen. Folgen Sie daher bitte den Hinweisen in der Installationsanleitung für das vorkonfigurierte Wiki. Dieses Wiki enthält auch die Hilfeseiten; Verweise auf das Hilfesystem sind im Text mit einer Hinterlegung markiert.
Nahezu alles an MoinMoin kann durch ein ausgeklügeltes Plugin-Konzept verändert werden. Das Aussehen könnnen Sie durch ein eigenes Theme (siehe Kapitel theme) umgestalten. Mit einem Parser (siehe parser plugins können Sie Inhalte interpretieren und diese dann darstellen. Ein Macro (siehe macro plugins) dient dazu, in Form eines Kommandos etwas auf einer Seite einzufügen, während Sie mit einer Action (siehe Kapitel action plugins) bestimmen, was auf "Knopfdruck" geschehen soll. Ein Formatter siehe Kapitel formatter plugins) und Kapitel formatter) erlaubt eine Ausgabe in einem beliebigen Format. Filter (filter plugins) werden zum Erstellen des Suchindex am Beispiel von Dateianhängen benutzt. Mit XMLRPC (siehe Kapitel xmlrpc und xmlrpc plugins) können Sie über eine Netzwerkverbindung mit MoinMoin kommunizieren.
Falls Sie Verbesserungswünsche haben, können Sie einen Feature Request <<FootNote(FeatureRequest)>> erstellen - eventuell sogar mit einem Patch, wenn Sie das Feature bereits implementiert haben.
Im Nachfolgenden beziehen sich alle Beschreibungen auf den Standalone-Server und das vorkonfigurierte Wiki. <<Anchor(wikistarten)>> Um dieses zu starten, gehen Sie in das Verzeichnis moin-1.6 und rufen Sie das Programm moin.py auf. Ihr lokales Wiki erreichen Sie dann über die URL http://localhost:8080/ (siehe Abbildung). Falls Einstellungen geändert werden müssen, werden diese in der Konfigurationsdatei wikiconfig.py im gleichen Verzeichnis vorgenommen (siehe HilfeZurKonfiguration).
<<Anchor(perswiki)>>
|
|
|
Das persönliche Wiki |
Referenz der Klassen und Methoden von MoinMoin
Das nachfolgende Schaubild<<FootNote(mit freundlicher Genehmigung von Nir Soffer)>> zeigt die wesentlichen Klassen, die beim Ablauf des Programms moin.py eine Wiki-Seite in Ihrem Browser ausgeben. Die einzelnen Klassen stellen einzelne Schritte dar. Beispielsweise wird über eine Action eine Seite durch Page angefordert. Diese Seite wird durch das Theme mit weiteren Inhalten ausgestattet und dann als HTML-Seite auf ihrem Browser ausgegeben. <<Anchor(Schaubild)>>
|
|
|
Prinzipieller Aufbau von MoinMoin |
Diesen Klassen ist gemeinsam, dass sie über ein request-Objekt miteinander kommunizieren. Mit einem eigenem request-Objekt (siehe Kapitel request) können Sie aus einer anderen Applikation MoinMoin nutzen, um ein Wiki in Ihre Applikation zu integrieren.
Damit das Arbeiten mit dem MoinMoin-Code einfacher fällt, stelle ich Ihnen zunächst einige Klassen aus der Bibliothek vor, jedoch kann ich deren Methoden nicht komplett aufführen und auch nicht alle Parameter beschreiben. Ich beschränke mich hier auf jene, die wir dann auch in Beispielen verwenden werden. Da Sie den Sourcecode vorliegen haben, werden Sie noch viele andere interessante Klassen und Methoden finden. Gerne können Sie die Entwickler auch in ihrem chatroom #moin auf chat.freenode.net besuchen, wenn etwas unklar ist oder Sie über weitere Möglichkeiten diskutieren wollen.
Anhand des nachfolgenden Beispiels sehen Sie, wie Sie einige Funktionen zum Ausgeben einer Seite anwenden können.
#!python from MoinMoin.Page import Page from MoinMoin.request import request_cli request = request_cli.Request() pagename = u'StartSeite' text = Page(request, pagename).get_raw_body() print text
##||Ausgabe der StartSeite||
Zunächst werden von MoinMoin.Page die Page-Klasse und von MoinMoin.request das Modul request_cli importiert. Die Page Klasse (siehe Kapitel Page) benötigen Sie für den lesenden Zugriff auf eine Wiki-Seite. Die Klasse request_cli (siehe Kapitel request) benötigen Sie für alle Zugriffe auf das Wiki, die von der Python shell erfolgen.
Der Variablen request wird mit request = request_cli.Request() ein frisch erzeugtes request-Objekt zugewiesen.
Die Variable pagename bekommt als unicode String z.B. mit u'StartSeite' den Namen der Seite zugewiesen, die Sie ausgeben möchten.
Die nachfolgende Zeile text = Page(request, pagename).get_raw_body() wendet aus der Klasse Page die Methode get_raw_body (siehe Kapitel page.get_raw_body) an. Diese liest den Inhalt der Seite und speichert deren Rückgabewert in der Variablen text.
Mit print text wird der Inhalt von text ausgegeben.
#!wiki comment
Um die Beispiele im Python-Interpreter ausprobieren zu können, sollten Sie in das Verzeichnis {{{moin-1.6
wechseln. In diesem Verzeichnis können Sie durch moin.py den Standalone-Server starten, um Ihre Änderungen mitzuverfolgen.
In den Beispielen, die auf eine Wiki-Seite oder deren Dateianhänge (attachments) zugreifen, werden immer auch die Zugriffsrechte des ausführenden Benutzers geprüft. Daher gewährleisten Sie bitte auch, dass in Ihrer Wiki-Konfiguration dem entsprechenden Benutzer diese Rechte erteilt werden.
In der Konfigurationsdatei wikiconfig.py sollte daher folgende Zeile enthalten sein:
acl_rights_default = uAll:read,write,delete,revert,admin'
Diese Zeile regelt, dass in den nachfolgenden Beispielen alle Benutzer auf jeder Seite des Wikis die Rechte zum Lesen, Schreiben, Löschen, Wiederherstellen und zur Administration der Seite haben. }}} <<Anchor(request)>>
request
Den Klassen (siehe Abbildung) ist das zentrale request-Objekt gemeinsam. Dieses enthält Daten und Objekte, die für die Bearbeitung in den einzelnen Programmen benötigt werden; u.a. den Zugriff auf die Konfigurationsdatei.
Neben einem request-Objekt (request_cli), dass Sie zum Arbeiten in der Python-Shell verwenden können, unterstützt MoinMoin auch cgi, fcgi, mod_python, standalone, twisted und wsgi. (siehe HilfeZurInstallation)
Sehr praktisch ist, dass Sie mit diesem request-Objekt in der Python-Shell viele der Methoden, die für die Plugin-Entwicklung (siehe Kapitel Plugins) wichtig sind, ausprobieren und kennen lernen können.
Falls Sie bereits eine in Python entwickelte Applikation haben, können Sie unter anderem mit diesem request-Objekt auch mit einem MoinMoin-Wiki kommunizieren oder die Wiki- Funktionalitäten anwenden. Das nachfolgende Beispiel zeigt, wie Sie ein request-Objekt in der Python-Shell bilden können, und wie Sie von der Shell aus auf das Wiki zugreifen können.
#!python from MoinMoin.request import request_cli request = request_cli.Request()
##[caption=request abgeleitet von request_cli]{request Object}
Sie können sich mit help(request) die Docstrings von request ausgeben lassen. Die Ausgabe beginnt mit dem folgendem Text:
Help on Request in module MoinMoin.request.request_cli object: class Request(MoinMoin.request.RequestBase) | specialized on command line interface and script requests | | Method resolution order: | Request ....
request.getText
Die Methode request.getText ermöglicht die Übersetzung von Text (z.B. die Beschriftung der Navigationselemente) in die voreingestellte Sprache des Benutzers.
#!python [caption=Internationalisierung]{getText}
request.lang = 'de'
_ = request.getText
print _("Mail me my account data")
Für das cli-request-Objekt (command line interface) wird diese Funktionalität derzeit nicht unterstützt. Daher sind die Ausgaben, der in der Beschreibung verwendeten Beispiele auf der Basis von request_cli.Request() in englisch.
MoinMoin wird englischsprachig entwickelt und der Text dann in die jeweilige Benutzersprache übersetzt. Sie finden unter moin-1.6/MoinMoin/i18 in der Datei de.MoinMoin.po die deutschen Übersetzungen. Evtl. finden Sie in dieser Datei dort einen passenden Ausgabetext für Ihre Erweiterung. Dann können Sie direkt von den vorhandenen Übersetzungen profitieren. Die Übersetzungsarbeit wird gemeinschaftlich von vielen Nutzern auf dem Wiki MoinMaster <<FootNote(EditingOnMoinMaster)>> durchgeführt. Dieses Wiki dient auch der Entwicklung der Hilfeseiten, die Sie in Ihrem Wiki vorfinden.
<<Anchor(requestusermay)>>
request.user.may
Mit den Methoden von request.user.may werden die Rechte des Benutzers für eine Seite überprüft.
#!python pagename = u'StartSeite' print request.user.may.read(pagename) print request.user.may.write(pagename) print request.user.may.delete(pagename) print request.user.may.revert(pagename) print request.user.may.admin(pagename)
##[caption=Abfrage der Zugriffsrechte]{request.user.may}
<<Anchor(Page)>>
Page
Die Klasse Page wird für den readonly-Zugriff auf eine Seite verwendet. Sie können damit auch auf ältere Versionen einer Seite als die aktuelle zugreifen. Bei Operationen, die auf Wiki-Seiten oder deren Attachments vorgenommen werden, werden die Zugriffsrechte des Benutzers überprüft (mit sog. ACLs, siehe HilfeZuAccessControlLists).
#!python from MoinMoin.Page import Page
##[caption=import Page]{Page Object}
Page.exists()
Mit der Methode Page.exists() stellen Sie fest, ob eine Seite bereits existiert, z.B.:
#!python [caption=Zeige ob die Seite existiert]{Page exists}
pagename = u'StartSeite'
print Page(request, pagename).exists()
Ausgabe:
True
Page.getRevList()
Die Methode Page.getRevList() gibt eine Liste der Revisionen einer Seite zurück. Die aktuelle Revision wird als erste angezeigt.
#!python pagename = u'StartSeite' print Page(request, pagename).getRevList()
##[caption=Zeige die Revisionen einer Seite]{Page getRevList}
Ausgabe:
[2, 1]
Page.current_rev()
Die Methode Page.current_rev() zeigt die aktuelle Revision einer Seite an.
e#!python pagename = u'StartSeite' print Page(request, pagename).current_rev()
##[caption=Zeige die aktuelle Revision einer Seite]
Ausgabe:
2
##==== Page.getPagePath() ====
## this method will be removed soon
##Wenn Sie den Dateipfad zu einer Wiki-Seite wissen möchten, wenden Sie die Methode {{{Page.getPagePath()}}} an.
k##{{{{{#!python
6##pagename = u'StartSeite'
>##print Page(request, pagename).getPagePath()
##}}}}}
S##[caption=Zeige den Pfad zu einer Seite im Dateisystem]{Page getPagePath}
m##Ausgabe:
c##{{{{{
4##/home/workspace/moin-1.6/wiki/underlay/pages/StartSeite
##}}}}}
<<Anchor(pagegetrawbody)>>
Page.get_raw_body()
Um den Seiteninhalt auszulesen, wenden Sie Page.get_raw_body() an.
#!python pagename = u'StartSeite' text = Page(request, pagename).get_raw_body() print text
##[caption=Zeige den Inhalt einer Wiki Seite]{Page getrawbody}
Worum geht es in diesem Wiki? Wichtige Einstiegsseiten: * AktuelleÄnderungen: Sehen Sie, woran gerade gearbeitet wird * SeiteFinden: Durchsuchen Sie das Wiki * WegWeiser: Finden Sie sich im Wiki zurecht * WikiSandkasten: Probieren Sie das Editieren im Wiki aus * SyntaxReferenz: Schnellübersicht der Darstellungs- und Textauszeichnungsmöglichkeiten '''Beachten Sie auch die englische Startseite: FrontPage.''' == Wie man diese Seiten benutzt == Ein Wiki wird von einer gemeinschaftlichen Idee getragen, jeder kann seinen Beitrag leisten und daran teilhaben: * Bearbeiten Sie jede Seite, indem Sie auf "<<GetText(Edit)>>" in der oberen oder unteren Leiste klicken * Erstellen Sie einen Link zu einer anderen Seite durch das Aneinanderreihen von groß geschriebenen Worten (z. B. AktuelleÄnderungen) * Suchen Sie nach Seiten mit dem Suchfeld oben auf der Seite (Titel- oder Volltextsuche) * Auf HilfeFürAnfänger stehen weitere Hinweise; HilfeInhalt verlinkt auf alle Hilfeseiten. Um mehr darüber zu erfahren, was ein WikiWikiWeb ist, können Sie DseWiki:WarumWikiFunktioniert lesen. Antworten auf häufig gestellte Fragen finden Sie auch auf der Seite HilfeAllgemein/ FragenUndAntworten. Dieses Wiki basiert auf [[http://moinmo.in/|MoinMoin]]
Page.send_page()
Mit Page.send_page() senden Sie die formatierte Seite an das Ausgabegerät (meistens an den Browser). Optional können Sie eine Nachricht über den msg-Parameter ausgeben. Diese Nachricht wird dann in einer Box oberhalb der Seite angezeigt. Wird diese Methode nicht für einen Browser angewendet, sollte auch kein http_header verschickt werden.
#!python pagename = u'StartSeite' Page(request, pagename).send_page(msg=u'Done', emit_headers=False)
㴖##[caption=Sende eine Seite an das Ausgabegerät]{Page sendpage}
Die Ausgabe in der Konsole beginnt mit:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html;charset=utf-8"> <meta name="robots" content="index,nofollow"> <title>StartSeite - MoinMoin DesktopEdition</title> <script type="text/javascript" src="/moin_static160/common/js/common.js"> </script> <script type="text/javascript"> <!-- var search_hint = "Search"; //--> </script>
PageEditor
Die Klasse PageEditor wird für alle Schreiboperationen auf eine Seite des Wikis verwendet. Bei Operationen, die auf Wiki-Seiten oder deren Attachments vorgenommen werden, werden die Zugriffsrechte des Benutzers überprüft. (siehe HilfeZuAccessControlLists)
k#!python [caption=import PageEditor]{import PageEditor}
from MoinMoin.PageEditor import PageEditor
PageEditor.saveText()
PageEditor.saveText() wird verwendet, um Text auf einer Seite zu speichern. Neben dem Text, den Sie speichern wollen, müssen Sie auch noch die Revision der Seite als Parameter angeben.
#!python pagename = u'TestSeite' text = u'Das ist ein Beispiel' print PageEditor(request, pagename).saveText(text, 0)
##[caption=Speichere eine Seite im Wiki]{PageEditor saveText}
Die Bestätigung für das erfolgreiche Speichern lautet:
'Thank you for your changes. Your attention to detail is appreciated.'
Diese Seite befindet sich jetzt im Wiki, wie Sie leicht mit einem Web-Browser überprüfen können. http://localhost:8080/TestSeite
Wenn Sie den Aufruf PageEditor(request, pagename).saveText(text, 0) wiederholen, ohne eine Änderung am text durchzuführen. wird das Speichern verweigert und Sie erhalten eine Fehlermeldung ausgelöst durch eine Ausnahme.
eᜄMoinMoin.PageEditor.Unchanged: You did not change the page content, not saved!
Diese Fehlermeldung sollte immer mit einem try ... except:-Block abgefangen werden, siehe nachfolgendes Beispiel:
lp#!python
pagename = u'TestSeite'
page = PageEditor(request, pagename)
text = u'Das ist ein Beispiel'
try:
page.saveText(text, 0)
except page.Unchanged:
print "You did not change the page content, not saved!"
㿈##[caption=Umgang mit ungeänderten Inhalt]
<<Anchor(PageEditordeletePage)>>
PageEditor.deletePage()
Die Methode PageEditor.deletePage wird verwendet, um eine Seite zu löschen. Wird eine Seite gelöscht, wird eine neue Revision ohne Datendatei erzeugt -- die alten Versionen der Seite bleiben aber erhalten und können auch wieder hergestellt werden.
#!python pagename = u'TestSeite' print PageEditor(request, pagename).deletePage()
## [caption=Lösche eine Seite]{PageEditor deletePage}
Die Bestätigung für das erfolgreiche Löschen lautet:
(True, u'Page "TestSeite" was successfully deleted!')
AttachFile
Das Modul AttachFile enthält die Funktionen, die benötigt werden, um Attachments auf Wiki-Seiten abzulegen (siehe HilfeZuAktionen/DateiAnhänge) oder von dort zu laden. Es ist geplant in einer zukünftigen MoinMoin-Version, dass Attachments ähnlich wie Wiki-Seiten behandelt werden (und damit dann auch versionierbar werden). Dadurch wird dann diese Klasse entfallen.
#!python from MoinMoin.action import AttachFile
## [caption=import AttachFile]{import AttachFile}
AttachFile.exists()
Die Methode AttachFile.exists() stellt fest, ob ein bestimmter Dateianhang schon auf der Seite existiert.
#!python pagename = u'WikiSandkasten' attachment = u'dateianhang.png' print AttachFile.exists(request, pagename, attachment)
## [caption=Zeige ob das Attachment existiert]{AttachFile exists}
Ausgabe:
True
AttachFile.getAttachDir()
Die Methode AttachFile.getAttachDir() gibt den Pfad zu dem Attachment zurück.
#!python pagename = u'WikiSandkasten' attachment = u'dateianhang.png' print AttachFile.getAttachDir(request, pagename)
## [caption=Zeige den Pfad eines Attachments im Dateisystem]
Ausgabe:
/home/workspace/moin-1.6/wiki/underlay/pages/ WikiSandkasten/attachments
AttachFile.getAttachUrl()
Mit der Methode AttachFile.getAttachUrl() erhalten Sie die URL Ihres Attachments.
#!python pagename = u'WikiSandkasten' attachment = u'dateianhang.png' print AttachFile.getAttachUrl(pagename, attachment, request)
## [caption=Zeige die URL eines Attachments]{AttachFile getAttachUrl}
Ausgabe:
./WikiSandkasten?action=AttachFile&do=get&target=dateianhang.png
logfile
MoinMoin unterscheidet zwei Logging-Systeme: Mit eventlog werden hauptsächlich Ereignisse, wie mit dem Wiki umgegangen wird, für statistische Auswertungen festgehalten, z.B. welcher Browser eingesetzt wird oder welche Seiten an einem Tag angeschaut wurden. Das editlog speichert Ereignisse, wann eine Seite erstellt, bearbeitet oder gelöscht wurde, und diese Information werden auf der Seite Aktuelle Änderungen oder im Info Bereich der Seite angezeigt. <<Anchor(eventlog)>>
logfile.eventlog
Die Klasse eventlog verwaltet Zugriffe auf Wiki-Seiten. Sie haben die Möglichkeit zwischen zwei Filtern zu wählen. 'VIEWPAGE' kennzeichnet die angesehenen Seiten und 'SAVEPAGE' die gespeicherten. Das nachfolgende Beispiel zählt die Zugriffe auf die StartSeite. Bevor die Seitenzugriffe gezählt werden, wird überprüft, ob der Benutzer die zu zählende Seite lesen darf. Ist dies nicht der Fall, wird der Wert 0 ausgegeben.
#!python
from MoinMoin.logfile import eventlog
event_type = u'VIEWPAGE'
pagename = u'StartSeite'
event_log = eventlog.EventLog(request)
count = 0
if request.user.may.read(pagename):
test = filter(lambda line: line[1] in event_type and line[2]['pagename'] == pagename, event_log)
count = len(test)
print count
## [caption=Zeige wie häufig eine Seite angeschaut wurde]{logfile eventlog}
Ausgabe:
8
logfile.editlog
Mit Hilfe der Klasse logfile.editlog erfahren Sie etwas über die Bearbeitungsgeschichte einer Wiki-Seite. Wiki-Seiten können erstellt, umbenannt und gelöscht werden. Dies wird im editlog vermerkt. u'SAVENEW' für neu angelegte Seiten, u'SAVE/RENAME' für Seiten die umbenannt wurden, u'SAVE' für gelöschte Seiten, (siehe Kapitel PageEditor.deletePage). Das nachfolgende Beispiel zeigt die neu erstellten Wiki-Seiten in Ihrem Wiki und das Erstellungsdatum der Seiten. Es werden durch den Vergleich line.action == 'SAVENEW' nur Seiten ausgegeben, die in Ihrem Wiki neu angelegt wurden.
#!python
from MoinMoin import wikiutil
from MoinMoin.logfile import editlog
edit_log = editlog.EditLog(request)
for line in edit_log.reverse():
if (request.user.may.read(line.pagename) and line.action == 'SAVENEW'):
timestamp = request.user.getTime(wikiutil.version2timestamp(line.ed_time_usecs))
year, month, day = timestamp[0:3]
print "%s %s.%s.%s" % (line.pagename, day, month, year)
## [caption=Zeige die letzten Änderungen]{logfile editlog}
Ausgabe:
ExamplePage1 2007-11-3 ExamplePage2 2007-11-3 ExamplePage3 2007-11-4
<<Anchor(wikidicts)>>
wikidicts
Mit den Methoden der Klasse wikidicts erhalten Sie Zugriff auf verschiedene Dictionaries, die Sie mit Wiki-Seiten anlegen können. Es gibt ein Dictionary für Gruppen, mit denen Sie u.a. Benutzer zuordnen können, und eins für die Verarbeitung von Variablen, wie sie in dicts verwendet werden. Diese erlauben es Ihnen zu je einem Schlüssel einen Wert zu definieren.
#!python from MoinMoin import wikidicts
##[caption=import wikidicts]{import wikidicts}
#!wiki comment
In {{{HelpOnConfiguration
sind die beiden Variablen page_group_regex und page_dict_regex beschrieben. Mit der Definition der Variablen page_group_regex legen Sie fest, welche Seiten als Group-Dictionaries verwendet werden sollen (wikidicts.Group()). Mit der Variablen page_dict_regex legen Sie fest, welche Seiten durch wikidicts.Dict() auswertbar werden.
Die Voreinstellungen sind:
page_group_regex = u'$[a-z0-9]$Group$'
page_dict_regex = u'$[a-z0-9]$Dict$' }}}
wikidicts.Group()
Mit der Methode wikidicts.Group() können Sie feststellen, wer oder was in einer bestimmten Gruppe ist. Durch die Default-Einstellungen enden diese Seiten auf Group. Um das folgende Beispiel auszuprobieren sollten, Sie eine Seite die mit Group endet in Ihrem Wiki anlegen. Im Beispiel heißt die Seite UserGroup. Dort speichern Sie in Form einer Punkte-Liste (siehe HilfeZuListen) einige Benutzer. Diese Gruppen finden u.a. Verwendung bei der Zuweisung von Zugriffsrechten. Sie können diese Definition dazu verwenden, um plugins so zu schreiben, dass bestimmte Funktionen nur Mitgliedern einer Gruppe zugänglich sind. siehe HilfeZuAccessControlLists
#!python pagename = u'UserGroup' user_group = wikidicts.Group(request, pagename) members = user_group.members() print members print "Ist der Benutzer in der Gruppe: %s" % request.user.name in members
##[caption=Zeige die Mitglieder einer "GroupSeite"]{wikidicts.Group}
Ausgabe:
[u'ExampleUser', u'TestUser'] Ist der Benutzer in der Gruppe: False
wikidicts.Dict()
Mit der Methode wikidicts.Dict() können Sie Daten von Seiten, die auf Dict enden auslesen. siehe HelpOnDictionaries Wenn Sie auf einer Seite !MyDict als Unterseite Ihrer Homepage in Ihrem Wiki in der Syntax einer Defintions-Liste (siehe HilfeZuListen) einen Key var1 mit dem Wert Wert1 anlegen, zeigt Ihnen das folgende Beispiel, wie Sie darauf zugreifen können.
#!python pagename = u'MyDict' key = u'var1' d = wikidicts.Dict(request, pagename) result = d.get(key, '') print result
## [caption=Auslesen von Variablen einer "Dict" Seite]{wikidicts.Dict}
Ausgabe:
Wert1
Das Macro GetVal wendet diese Methode an. Sie können den Wert1 überall dort einfügen, wo Sie das Macro <<GetVal(MyDict,var1)>> in den Wiki-Text schreiben. Diese Variable lässt sich damit auch von einer anderen Wiki-Seite benutzen. (siehe HelpOnVariables)
wikiutil
Die Klasse wikiutil enthält diverse Utility-Funktionen.
#!python from MoinMoin import wikiutil
## [caption=import wikiutil]{import wikiutil}
wikiutil.escape()
Mit der Methode wikiutil.escape() maskieren Sie mögliche HTML-Sonderzeichen. Alles, was HTML-Sonderzeichen enthält, muss vor der Ausgabe escaped werden. Diese Methode wendet auch der Formatter (siehe Seite formatter) an.
#!python print wikiutil.escape(u'<html>')
##[caption=Maskieren von HTML-Steuerzeichen]{wikiutil escape}
Ausgabe:
<html>
<<Anchor(wikiutilcreateTicket)>>
wikiutil.createTicket()
Durch Anwendung der Methode wikiutil.createTicket() erstellen Sie ein Ticket, das Sie zur Verifikation von Formularen verwenden können. Dadurch können Sie überprüfen, ob die eingehenden Formulardaten aus einem von Ihnen erstellten Formular stammen (siehe Beispiel).
#!python print wikiutil.createTicket(request)
##[caption=Schlüsselwort für Formularoperationen generieren]{wikiutil createTicket}
Ausgabe:
0046e8506e.None.show.8ea03fb9d6e50bf60721aa
wikiutil.checkTicket()
Mit der Methode wikiutil.checkTicket() wird überprüft, ob das Ticket dem System bekannt ist (siehe Beispiel).
#!python print wikiutil.checkTicket(request, '0046e8506e.None.show.8ea03fb9d6e50bf60721aa')
##[caption=Ticket überprüfen]{wikiutil checkTicket}
Ausgabe:
True
<<Anchor(wikiutilinvokeextensionfunction)>>
wikiutil.invoke_extension_function()
Die Anwendung der Methode wikiutil.invoke_extension_function() ermöglicht es Ihnen, komfortabel Parameter Ihrer Macros (siehe Kapitel Plugins macro) auszuwerten. Durch die Definition eines Defaultwerts wird der Datentyp des Parameters festgelegt. Durch Vorgabe einer Liste möglicher Eingaben werden nur Eingaben aus dieser Liste zugelassen. Auf abweichende Eingaben wird mit einer Fehlermeldung hingewiesen.
wikiutil.version2timestamp()
Mit der Methode wikiutil.version2timestamp() wird die Zeitinformation, die in MoinMoin verwendet wird in die UNIX Zeitinformation umgerechnet.
wikiutil.timestamp2version()
Mit der Methode wikiutil.timestamp2version() wird die UNIX Zeitinformation, in die in MoinMoin verwendete Zeit umgerechnet.
user
Die Klasse User repräsentiert einen Benutzer und gibt Zugriff auf sein Profil.
#!python from MoinMoin.user import User
##[caption=import User]{import User}
user.name
Auf der Variablen user.name ist der Benutzername gespeichert. Wenn Sie einen Benutzer in ihrem Wiki mit dem Namen !ExampleUser haben, wird dieser Name im nachfolgendem Beispiel ausgegeben.
s#!python user = User(request, name=u'ExampleUser') print user.name
c## [caption=Zeige den Benutzernamen]{User exists}
user.exists()
Die Methode user.exists() wird verwendet, um festzustellen ob der Benutzer existiert.
#!python user = User(request, name=u'ExampleUser') print user.exists()
## [caption=Zeige ob der Benutzername definiert ist]
Ausgabe:
Attached Files
To refer to attachments on a page, use attachment:filename, as shown below in the list of files. Do NOT use the URL of the [get] link, since this is subject to change and can break easily.
You are not allowed to attach a file to this page.