← Back to branch summary

~ubuntu-branches/ubuntu/natty/moin/natty-updates

« back to all changes in this revision

Viewing changes to MoinMoin/events/__init__.py

  • Committer: Bazaar Package Importer
  • Author(s): Jonas Smedegaard
  • Date: 2008-06-22 21:17:13 UTC
  • mfrom: (0.9.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080622211713-fpo2zrq3s5dfecxg
Tags: 1.7.0-3
Simplify /etc/moin/wikilist format: "USER URL" (drop unneeded middle
CONFIG_DIR that was wrongly advertised as DATA_DIR).  Make
moin-mass-migrate handle both formats and warn about deprecation of
the old one.

Show diffs side-by-side

added added

removed removed

Lines of Context:
MoinMoin/events/__init__.py
 
1
# -*- coding: iso-8859-1 -*-
 
2
"""
 
3
    MoinMoin - event (notification) framework
 
4
 
 
5
    This code abstracts event handling in MoinMoin,
 
6
    currently for notifications. It implements the observer pattern.
 
7
 
 
8
    @copyright: 2007 by Karol Nowak <grywacz@gmail.com>
 
9
    @license: GNU GPL, see COPYING for details.
 
10
"""
 
11
 
 
12
from MoinMoin import log
 
13
logging = log.getLogger(__name__)
 
14
 
 
15
from MoinMoin import wikiutil
 
16
from MoinMoin.util import pysupport
 
17
from MoinMoin.wikiutil import PluginAttributeError
 
18
 
 
19
# Create a list of extension actions from the package directory
 
20
modules = pysupport.getPackageModules(__file__)
 
21
 
 
22
# Dummy pseudo-getText function used in event descriptions,
 
23
# so that they get into .po files
 
24
_ = lambda x: x
 
25
 
 
26
 
 
27
class Event(object):
 
28
    """A class handling information common to all events."""
 
29
 
 
30
    # NOTE: each Event subclass must have a unique name attribute
 
31
    name = u"Event"
 
32
 
 
33
    def __init__(self, request):
 
34
        self.request = request
 
35
 
 
36
 
 
37
class PageEvent(Event):
 
38
    """An event related to a page change"""
 
39
 
 
40
    name = u"PageEvent"
 
41
 
 
42
    def __init__(self, request):
 
43
        Event.__init__(self, request)
 
44
 
 
45
 
 
46
class PageChangedEvent(PageEvent):
 
47
 
 
48
    name = u"PageChangedEvent"
 
49
    description = _(u"""Page has been modified""")
 
50
    req_superuser = False
 
51
 
 
52
    def __init__(self, request, page, comment):
 
53
        PageEvent.__init__(self, request)
 
54
        self.page = page
 
55
        self.comment = comment
 
56
 
 
57
 
 
58
class TrivialPageChangedEvent(PageEvent):
 
59
 
 
60
    name = u"TrivialPageChangedEvent"
 
61
    description = _(u"Page has been modified in a trivial fashion")
 
62
    req_superuser = False
 
63
 
 
64
    def __init__(self, request, page, comment):
 
65
        PageEvent.__init__(self, request)
 
66
        self.page = page
 
67
        self.comment = comment
 
68
 
 
69
 
 
70
class PageRenamedEvent(PageEvent):
 
71
 
 
72
    name = u"PageRenamedEvent"
 
73
    description = _(u"""Page has been renamed""")
 
74
    req_superuser = False
 
75
 
 
76
    def __init__(self, request, page, old_page, comment=""):
 
77
        PageEvent.__init__(self, request)
 
78
        self.page = page
 
79
        self.old_page = old_page
 
80
        self.comment = comment
 
81
 
 
82
 
 
83
class PageDeletedEvent(PageEvent):
 
84
 
 
85
    name = u"PageDeletedEvent"
 
86
    description = _(u"""Page has been deleted""")
 
87
    req_superuser = False
 
88
 
 
89
    def __init__(self, request, page, comment):
 
90
        PageEvent.__init__(self, request)
 
91
        self.page = page
 
92
        self.comment = comment
 
93
 
 
94
 
 
95
class PageCopiedEvent(PageEvent):
 
96
 
 
97
    name = u"PageCopiedEvent"
 
98
    description = _(u"""Page has been copied""")
 
99
    req_superuser = False
 
100
 
 
101
    def __init__(self, request, page, old_page, comment):
 
102
        PageEvent.__init__(self, request)
 
103
        self.page = page
 
104
        self.old_page = old_page
 
105
        self.comment = comment
 
106
 
 
107
 
 
108
class FileAttachedEvent(PageEvent):
 
109
 
 
110
    name = u"FileAttachedEvent"
 
111
    description = _(u"""A new attachment has been added""")
 
112
    req_superuser = False
 
113
 
 
114
    def __init__(self, request, pagename, filename, size):
 
115
        PageEvent.__init__(self, request)
 
116
        self.request = request
 
117
        self.pagename = pagename
 
118
        self.filename = filename
 
119
        self.size = size
 
120
 
 
121
 
 
122
class PageRevertedEvent(PageEvent):
 
123
 
 
124
    name = u"PageRevertedEvent"
 
125
    description = _(u"""A page has been reverted to a previous state""")
 
126
    req_superuser = False
 
127
 
 
128
    def __init__(self, request, pagename, previous, current):
 
129
        PageEvent.__init__(self, request)
 
130
        self.pagename = pagename
 
131
        self.previous = previous
 
132
        self.current = current
 
133
 
 
134
 
 
135
class SubscribedToPageEvent(PageEvent):
 
136
 
 
137
    name = u"SubscribedToPageEvent"
 
138
    description = _(u"""A user has subscribed to a page""")
 
139
    req_superuser = True
 
140
 
 
141
    def __init__(self, request, pagename, username):
 
142
        PageEvent.__init__(self, request)
 
143
        self.pagename = pagename
 
144
        self.username = username
 
145
 
 
146
 
 
147
class JabberIDSetEvent(Event):
 
148
    """ Sent when user changes her Jabber ID """
 
149
 
 
150
    def __init__(self, request, jid):
 
151
        Event.__init__(self, request)
 
152
        self.jid = jid
 
153
 
 
154
class JabberIDUnsetEvent(Event):
 
155
    """ Sent when Jabber ID is no longer used
 
156
 
 
157
    Obviously this will be usually sent along with JabberIDSetEvent,
 
158
    because we require user's jabber id to be unique by default.
 
159
 
 
160
    """
 
161
    def __init__(self, request, jid):
 
162
        Event.__init__(self, request)
 
163
        self.jid = jid
 
164
 
 
165
class UserCreatedEvent(Event):
 
166
    """ Sent when a new user has been created """
 
167
 
 
168
    name = u"UserCreatedEvent"
 
169
    description = _(u"""A new account has been created""")
 
170
    req_superuser = True
 
171
 
 
172
    def __init__(self, request, user):
 
173
        Event.__init__(self, request)
 
174
        self.user = user
 
175
 
 
176
class PagePreSaveEvent(Event):
 
177
    """ Event sent when a page is about to be saved
 
178
 
 
179
    This can be used to abort a save, for instance,
 
180
    if handler returns
 
181
 
 
182
    """
 
183
 
 
184
    name = u"PagePreSaveEvent"
 
185
 
 
186
    def __init__(self, request, page_editor, new_text):
 
187
        Event.__init__(self, request)
 
188
        self.page_editor = page_editor
 
189
        self.new_text = new_text
 
190
 
 
191
 
 
192
class EventResult:
 
193
    """ This is a base class for messages passed from event handlers """
 
194
    pass
 
195
 
 
196
class Abort(EventResult):
 
197
    """ Result returned if handler wants to abort operation that sent the event """
 
198
    def __init__(self, reason):
 
199
        """
 
200
        @param reason: human-readable reason of failure
 
201
        """
 
202
        self.reason = reason
 
203
 
 
204
 
 
205
def get_handlers(cfg):
 
206
    """Create a list of available event handlers.
 
207
 
 
208
    Each handler is a handle() function defined in an plugin,
 
209
    pretty much like in case of actions.
 
210
 
 
211
    TODO: maybe make it less dumb? ;-)
 
212
 
 
213
    """
 
214
    event_handlers = []
 
215
    names = wikiutil.getPlugins("events", cfg)
 
216
 
 
217
    for name in names:
 
218
        try:
 
219
            handler = wikiutil.importPlugin(cfg, "events", name, "handle")
 
220
        except PluginAttributeError:
 
221
            handler = None
 
222
 
 
223
        if handler is not None:
 
224
            event_handlers.append(handler)
 
225
 
 
226
    return event_handlers
 
227
 
 
228
 
 
229
def send_event(event):
 
230
    """Function called from outside to process an event
 
231
 
 
232
    @return: a list of messages returned by handlers
 
233
    @rtype: list
 
234
    """
 
235
 
 
236
    # A list of messages generated by event handlers, passed back to caller
 
237
    msg = []
 
238
    cfg = event.request.cfg
 
239
 
 
240
    # Try to handle the event with each available handler (for now)
 
241
    for handle in cfg.event_handlers:
 
242
        retval = handle(event)
 
243
 
 
244
        assert retval is None or isinstance(retval, EventResult)
 
245
 
 
246
        if retval:
 
247
            msg.append(retval)
 
248
 
 
249
    return msg
 
250
 
 
251
def get_subscribable_events():
 
252
    """Create and return a list of user-visible events
 
253
 
 
254
    @return: A list of user-visible events described by dictionaries
 
255
    @rtype: dict
 
256
    """
 
257
    defs = globals()
 
258
    subscribable_events = {}
 
259
 
 
260
    for ev in defs.values():
 
261
        if type(ev) is type and issubclass(ev, Event) and ev.__dict__.has_key("description") and ev.__dict__.has_key("name"):
 
262
            subscribable_events[ev.name] = {'desc': ev.description, 'superuser': ev.req_superuser}
 
263
 
 
264
    return subscribable_events
 
265
 
 
266
# Get rid of the dummy getText so that it doesn't get imported with *
 
267
del _