Premiere version : mise en route du suivi.
[auf_roundup.git] / roundup / .svn / text-base / xmlrpc.py.svn-base
1 #
2 # Copyright (C) 2007 Stefan Seefeld
3 # All rights reserved.
4 # For license terms see the file COPYING.txt.
5 #
6
7 from roundup import hyperdb
8 from roundup.cgi.exceptions import *
9 from roundup.exceptions import UsageError
10 from roundup.date import Date, Range, Interval
11 from roundup import actions
12 from SimpleXMLRPCServer import *
13 from xmlrpclib import Binary
14
15 def translate(value):
16     """Translate value to becomes valid for XMLRPC transmission."""
17
18     if isinstance(value, (Date, Range, Interval)):
19         return repr(value)
20     elif type(value) is list:
21         return [translate(v) for v in value]
22     elif type(value) is tuple:
23         return tuple([translate(v) for v in value])
24     elif type(value) is dict:
25         return dict([[translate(k), translate(value[k])] for k in value])
26     else:
27         return value
28
29
30 def props_from_args(db, cl, args, itemid=None):
31     """Construct a list of properties from the given arguments,
32     and return them after validation."""
33
34     props = {}
35     for arg in args:
36         if isinstance(arg, Binary):
37             arg = arg.data
38         try :
39             key, value = arg.split('=', 1)
40         except ValueError :
41             raise UsageError, 'argument "%s" not propname=value'%arg
42         if isinstance(key, unicode):
43             try:
44                 key = key.encode ('ascii')
45             except UnicodeEncodeError:
46                 raise UsageError, 'argument %r is no valid ascii keyword'%key
47         if isinstance(value, unicode):
48             value = value.encode('utf-8')
49         if value:
50             try:
51                 props[key] = hyperdb.rawToHyperdb(db, cl, itemid,
52                                                   key, value)
53             except hyperdb.HyperdbValueError, message:
54                 raise UsageError, message
55         else:
56             props[key] = None
57
58     return props
59
60 class RoundupInstance:
61     """The RoundupInstance provides the interface accessible through
62     the Python XMLRPC mapping."""
63
64     def __init__(self, db, actions, translator):
65
66         self.db = db
67         self.actions = actions
68         self.translator = translator
69
70     def schema(self):
71         s = {}
72         for c in self.db.classes:
73             cls = self.db.classes[c]
74             props = [(n,repr(v)) for n,v in cls.properties.items()]
75             s[c] = props
76         return s
77
78     def list(self, classname, propname=None):
79         cl = self.db.getclass(classname)
80         if not propname:
81             propname = cl.labelprop()
82         result = [cl.get(itemid, propname)
83                   for itemid in cl.list()
84                   if self.db.security.hasPermission('View', self.db.getuid(),
85                                                     classname, propname, itemid)
86                   ]
87         return result
88
89     def filter(self, classname, search_matches, filterspec,
90                sort=[], group=[]):
91         cl = self.db.getclass(classname)
92         result = cl.filter(search_matches, filterspec, sort=sort, group=group)
93         return result
94
95     def display(self, designator, *properties):
96         classname, itemid = hyperdb.splitDesignator(designator)
97         cl = self.db.getclass(classname)
98         props = properties and list(properties) or cl.properties.keys()
99         props.sort()
100         for p in props:
101             if not self.db.security.hasPermission('View', self.db.getuid(),
102                                                   classname, p, itemid):
103                 raise Unauthorised('Permission to view %s of %s denied'%
104                                    (p, designator))
105             result = [(prop, cl.get(itemid, prop)) for prop in props]
106         return dict(result)
107
108     def create(self, classname, *args):
109         
110         if not self.db.security.hasPermission('Create', self.db.getuid(), classname):
111             raise Unauthorised('Permission to create %s denied'%classname)
112
113         cl = self.db.getclass(classname)
114
115         # convert types
116         props = props_from_args(self.db, cl, args)
117
118         # check for the key property
119         key = cl.getkey()
120         if key and not props.has_key(key):
121             raise UsageError, 'you must provide the "%s" property.'%key
122
123         for key in props:
124             if not self.db.security.hasPermission('Create', self.db.getuid(),
125                 classname, property=key):
126                 raise Unauthorised('Permission to create %s.%s denied'%(classname, key))
127
128         # do the actual create
129         try:
130             result = cl.create(**props)
131             self.db.commit()
132         except (TypeError, IndexError, ValueError), message:
133             raise UsageError, message
134         return result
135
136     def set(self, designator, *args):
137
138         classname, itemid = hyperdb.splitDesignator(designator)
139         cl = self.db.getclass(classname)
140         props = props_from_args(self.db, cl, args, itemid) # convert types
141         for p in props.iterkeys():
142             if not self.db.security.hasPermission('Edit', self.db.getuid(),
143                                                   classname, p, itemid):
144                 raise Unauthorised('Permission to edit %s of %s denied'%
145                                    (p, designator))
146         try:
147             result = cl.set(itemid, **props)
148             self.db.commit()
149         except (TypeError, IndexError, ValueError), message:
150             raise UsageError, message
151         return result
152
153
154     builtin_actions = {'retire': actions.Retire}
155
156     def action(self, name, *args):
157         """Execute a named action."""
158         
159         if name in self.actions:
160             action_type = self.actions[name]
161         elif name in self.builtin_actions:
162             action_type = self.builtin_actions[name]
163         else:
164             raise Exception('action "%s" is not supported %s' % (name, ','.join(self.actions.keys())))
165         action = action_type(self.db, self.translator)
166         return action.execute(*args)
167
168
169 class RoundupDispatcher(SimpleXMLRPCDispatcher):
170     """RoundupDispatcher bridges from cgi.client to RoundupInstance.
171     It expects user authentication to be done."""
172
173     def __init__(self, db, actions, translator,
174                  allow_none=False, encoding=None):
175
176         try:
177             # python2.5 and beyond
178             SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
179         except TypeError:
180             # python2.4
181             SimpleXMLRPCDispatcher.__init__(self)
182         self.register_instance(RoundupInstance(db, actions, translator))
183                  
184
185     def dispatch(self, input):
186         return self._marshaled_dispatch(input)
187
188     def _dispatch(self, method, params):
189
190         retn = SimpleXMLRPCDispatcher._dispatch(self, method, params)
191         retn = translate(retn)
192         return retn
193