~vcs-imports/quotient/main

« back to all changes in this revision

Viewing changes to quotient/admin.py

  • Committer: glyph
  • Date: 2003-10-26 23:44:25 UTC
  • Revision ID: Arch-1:unnamed@bazaar.ubuntu.com%series--4208--patch-749
whitespace

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
 
2
 
 
3
 
from quotient import im
4
 
from quotient import grabbers
5
 
from quotient import formless
6
 
 
7
 
from twisted.internet import reactor
8
 
 
9
 
from twisted.python import components
10
 
 
11
 
 
12
 
class IDomainAdmin(formless.TypedInterface):
13
 
    users = formless.List()
14
 
 
15
 
 
16
 
class CantRemove(list):
17
 
    def remove(self, x):
18
 
        return "Sorry, can't remove domains yet."
19
 
 
20
 
 
21
 
class DeleteUser(list):
22
 
    def remove(self, x):
23
 
        x.deleteUser()
24
 
 
25
 
 
26
 
class DomainAdmin:
27
 
    __implements__ = IDomainAdmin,
28
 
 
29
 
    def __init__(self, domain):
30
 
        self.domain = domain
31
 
 
32
 
    def __str__(self):
33
 
        try:
34
 
            ## Need a better way to figure out the domain name
35
 
            return '.'.join(self.domain.dirname.split('/')[-1].split('.')[:-1])
36
 
        except Exception, e:
37
 
            return repr(self)
38
 
 
39
 
    def _getUsers(self):
40
 
        return DeleteUser(iter(self.domain))
41
 
    users = property(_getUsers)
42
 
 
43
 
 
44
 
class IRealmAdmin(formless.TypedInterface):
45
 
    def addDomain(self, domainName = formless.String()):
46
 
        """Add domain
47
 
        
48
 
        Add a domain name to the domains which quotient will handle.
49
 
        """
50
 
        return None
51
 
    addDomain = formless.autocallable(addDomain)
52
 
 
53
 
    domains = formless.List()
54
 
    def shutdown(self):
55
 
        """Shutdown
56
 
 
57
 
        Shut down the quotient server.
58
 
        """
59
 
        return None
60
 
    shutdown = formless.autocallable(shutdown,action="Shutdown")
61
 
 
62
 
 
63
 
class IRealmAdminSipChoice(formless.TypedInterface):
64
 
    def addDomain(self,domainName=formless.String(), sip=formless.Boolean()):
65
 
        """Add domain
66
 
        
67
 
        Add a domain name to the domains for which quotient will recieve mail.
68
 
        You can also choose to have quotient serve as a sip registrar for this domain.
69
 
        """
70
 
        return None
71
 
    addDomain = formless.autocallable(addDomain)
72
 
 
73
 
    domains = formless.List()
74
 
    def shutdown(self):
75
 
        """Shutdown
76
 
 
77
 
        Shut down the quotient server.
78
 
        """
79
 
        return None
80
 
    shutdown = formless.autocallable(shutdown,action="Shutdown")
81
 
 
82
 
 
83
 
class IQuotientUser(formless.TypedInterface):
84
 
    fullname = formless.String(label="Name", description="Your full real name.")
85
 
    replyTo = formless.String(
86
 
        label="Reply to",
87
 
        description="The address to use as the From address when replying to messages.")
88
 
 
89
 
    def addPopGrabber(self, 
90
 
        username = grabbers.username, password = grabbers.password,
91
 
        host = grabbers.host, port = grabbers.popport, msgsPer = grabbers.msgsPer,
92
 
        ssl = grabbers.ssl):
93
 
        """Add Pop Grabber
94
 
        
95
 
        Add a POP3 email account to be checked by this Quotient account.
96
 
        """
97
 
        return grabbers.IGrabberObject
98
 
    addPopGrabber = formless.autocallable(addPopGrabber)
99
 
 
100
 
    def addIMAPGrabber(self,
101
 
        username = grabbers.username, password = grabbers.password,
102
 
        host = grabbers.host, port = grabbers.imapport, msgsPer = grabbers.msgsPer,
103
 
        ssl = grabbers.ssl):
104
 
        """Add IMAP Grabber
105
 
        
106
 
        Add an IMAP email account to be checked by this Quotient account.
107
 
        """
108
 
        return grabbers.IGrabberObject
109
 
    addIMAPGrabber = formless.autocallable(addIMAPGrabber)
110
 
 
111
 
    def addInstantMessagingPresence(self,
112
 
        inboundUsername = im.iUser,
113
 
        inboundPassword = im.iPass,
114
 
        inboundProtocol = im.iProto,
115
 
#        account = im.IInstantMessagingObject):
116
 
        outboundUsername = im.oUser,
117
 
        outboundPassword = im.oPass,
118
 
        outboundProtocol = im.oProto,
119
 
        host = grabbers.host,
120
 
        port = grabbers.port):
121
 
        """Add Presence
122
 
        
123
 
        Add an instant messaging presence on an IRC network"""
124
 
        return im.IInstantMessagingObject
125
 
    addInstantMessagingPresence = formless.autocallable(addInstantMessagingPresence)
126
 
 
127
 
    def importDirectory(self,
128
 
        d = formless.Directory(
129
 
            label="Directory",
130
 
            description="The directory on the server's filesystem to import.")):
131
 
        """Import Directory
132
 
        
133
 
        Import a directory full of email messages into this Quotient account.
134
 
        """
135
 
        return None
136
 
    importDirectory = formless.autocallable(importDirectory)
137
 
 
138
 
    def importMailbox(self,
139
 
        m = formless.String(
140
 
            label="Mailbox",
141
 
            description="The mailbox on the server's filesystem to import.")):
142
 
        """Import Mailbox
143
 
        
144
 
        Import an mbox-format file into this Quotient account.
145
 
        """
146
 
        return None
147
 
    importMailbox = formless.autocallable(importMailbox)
148
 
 
149
 
    tasks = formless.List()
150
 
 
151
 
 
152
 
class CheckDuplicateUser(formless.Compound):
153
 
    def coerceWithBinding(self, data, binding):
154
 
        try:
155
 
            binding.getAvatarByEmail('%s@%s' % tuple(data))
156
 
        except KeyError:
157
 
            return data
158
 
        raise formless.InputError('Sorry, the user %s@%s already exists. Please try again.' % tuple(data))
159
 
 
160
 
 
161
 
class IRealmSignup(formless.TypedInterface):
162
 
    def webSignUp(
163
 
        self,
164
 
        req=formless.Request(), # the web request
165
 
        localpartAndDomain=CheckDuplicateUser(
166
 
            [formless.String(label="Username"), 
167
 
            formless.Choice(label="Domain", choicesAttribute="domainNames")],
168
 
            label="EmailAddress"
169
 
        ),
170
 
        password=formless.Password(label="Password"),
171
 
        fullname=formless.String(label="Full name")):
172
 
        """Create Account
173
 
        
174
 
        Fill in the relevant information to create a new quotient account.
175
 
        """
176
 
        return formless.Object(IQuotientUser, label="New user")
177
 
    webSignUp = formless.autocallable(webSignUp)
178
 
 
179
 
 
180
 
class Administrator:
181
 
    __implements__ = IRealmSignup, IRealmAdmin
182
 
 
183
 
    def __init__(self, original, sipRegistrar=True):
184
 
        self.original = original
185
 
        for forward in ['webSignUp', 'getAvatarByEmail']:
186
 
            setattr(self, forward, getattr(self.original, forward))
187
 
        self.sipRegistrar = sipRegistrar
188
 
 
189
 
    def addDomain(self, domainName):
190
 
        self.original.addDomain(domainName)
191
 
        if self.sipRegistrar:
192
 
            sip = self.original.service.getServiceNamed("SIP-Registrar")
193
 
            sip.registry.addDomain(domainName)
194
 
 
195
 
    def shutdown(self):
196
 
        reactor.callLater(2, reactor.stop)
197
 
        return "The server will shut down in 2 seconds."
198
 
 
199
 
    domains = property(lambda self: CantRemove([DomainAdmin(x) for x in iter(self.original.domains)]))
200
 
 
201
 
    domainNames = property(lambda self: self.original.domainNames)
202
 
 
203
 
 
204
 
class SipChoiceAdministrator(Administrator):
205
 
    __implements__ = IRealmSignup, IRealmAdminSipChoice
206
 
 
207
 
    def addDomain(self, domainName, sip):
208
 
        self.sipRegistrar = sip
209
 
        Administrator.addDomain(self, domainName)
210
 
 
211
 
 
212