# Patchwork XMLRPC interface
#
-from django.core.exceptions import ImproperlyConfigured
from SimpleXMLRPCServer import SimpleXMLRPCDispatcher
from django.http import HttpResponse, HttpResponseRedirect, \
HttpResponseServerError
-from django.conf import settings
from django.core import urlresolvers
-from django.shortcuts import render_to_response
from django.contrib.auth import authenticate
-from patchwork.models import Patch, Project, Person, Bundle, State
+from patchwork.models import Patch, Project, Person, State
+from patchwork.views import patch_to_mbox
+from django.views.decorators.csrf import csrf_exempt
import sys
import base64
def _user_for_request(self, request):
- auth_header = None
+ auth_header = None
- if request.META.has_key('HTTP_AUTHORIZATION'):
- auth_header = request.META.get('HTTP_AUTHORIZATION')
- elif request.META.has_key('Authorization'):
- auth_header = request.META.get('Authorization')
+ if 'HTTP_AUTHORIZATION' in request.META:
+ auth_header = request.META.get('HTTP_AUTHORIZATION')
+ elif 'Authorization' in request.META:
+ auth_header = request.META.get('Authorization')
- if auth_header is None or auth_header == '':
+ if auth_header is None or auth_header == '':
raise Exception("No authentication credentials given")
str = auth_header.strip()
def _marshaled_dispatch(self, request):
try:
- params, method = xmlrpclib.loads(request.raw_post_data)
+ params, method = xmlrpclib.loads(request.body)
response = self._dispatch(request, method, params)
# wrap response in a singleton tuple
dispatcher = PatchworkXMLRPCDispatcher()
# XMLRPC view function
+@csrf_exempt
def xmlrpc(request):
if request.method != 'POST':
return HttpResponseRedirect(
try:
ret = dispatcher._marshaled_dispatch(request)
response.write(ret)
- except Exception, e:
+ except Exception:
return HttpResponseServerError()
return response
def person_to_dict(obj):
"""Return a trimmed down dictionary representation of a Person
object which is OK to send to the client."""
+
+ # Make sure we don't return None even if the user submitted a patch
+ # with no real name. XMLRPC can't marshall None.
+ if obj.name is not None:
+ name = obj.name
+ else:
+ name = obj.email
+
return \
{
'id' : obj.id,
'email' : obj.email,
- 'name' : obj.name,
+ 'name' : name,
'user' : unicode(obj.user).encode("utf-8"),
}
'project_id' : obj.project_id,
'state' : unicode(obj.state).encode("utf-8"),
'state_id' : obj.state_id,
+ 'archived' : obj.archived,
'submitter' : unicode(obj.submitter).encode("utf-8"),
'submitter_id' : obj.submitter_id,
'delegate' : unicode(obj.delegate).encode("utf-8"),
"project_id",
"submitter_id",
"delegate_id",
+ "archived",
"state_id",
"date",
"commit_ref",
elif parts[0] == 'submitter_id':
dfilter['submitter'] = Person.objects.filter(id =
filter[key])[0]
+ elif parts[0] == 'delegate_id':
+ dfilter['delegate'] = Person.objects.filter(id =
+ filter[key])[0]
elif parts[0] == 'state_id':
dfilter['state'] = State.objects.filter(id =
filter[key])[0]
patches = Patch.objects.filter(**dfilter)
if max_count > 0:
- return map(patch_to_dict, patches)[:max_count]
+ return map(patch_to_dict, patches[:max_count])
else:
return map(patch_to_dict, patches)
except:
return {}
+@xmlrpc_method(False)
+def patch_get_by_project_hash(project, hash):
+ """Return structure for the given patch hash."""
+ try:
+ patch = Patch.objects.filter(project__linkname = project,
+ hash = hash)[0]
+ return patch_to_dict(patch)
+ except:
+ return {}
+
@xmlrpc_method(False)
def patch_get_mbox(patch_id):
"""Return mbox string for the given patch ID."""
try:
patch = Patch.objects.filter(id = patch_id)[0]
- return patch.mbox().as_string()
+ return patch_to_mbox(patch).as_string(True)
except:
return ""