xmlrpc: support filtering by 'archived'

[patchwork] / apps / patchwork / views / xmlrpc.py

diff --git a/apps/patchwork/views/xmlrpc.py b/apps/patchwork/views/xmlrpc.py
index 791c89ef7ce534d2ed68e86cf4566c4102964a7d..84ed4089b346812f241789e35af4e69624302080 100644 (file)
--- a/apps/patchwork/views/xmlrpc.py
+++ b/apps/patchwork/views/xmlrpc.py
@@ -20,15 +20,14 @@
 # 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
@@ -58,14 +57,14 @@ class PatchworkXMLRPCDispatcher(SimpleXMLRPCDispatcher):
 
 
     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()
@@ -101,7 +100,7 @@ class PatchworkXMLRPCDispatcher(SimpleXMLRPCDispatcher):
 
     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
@@ -120,6 +119,7 @@ class PatchworkXMLRPCDispatcher(SimpleXMLRPCDispatcher):
 dispatcher = PatchworkXMLRPCDispatcher()
 
 # XMLRPC view function
+@csrf_exempt
 def xmlrpc(request):
     if request.method != 'POST':
         return HttpResponseRedirect(
@@ -130,7 +130,7 @@ def xmlrpc(request):
     try:
         ret = dispatcher._marshaled_dispatch(request)
         response.write(ret)
-    except Exception, e:
+    except Exception:
         return HttpResponseServerError()
 
     return response
@@ -168,12 +168,20 @@ def project_to_dict(obj):
 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,
-         'user'         : str(obj.user),
+         'name'         : name,
+         'user'         : unicode(obj.user).encode("utf-8"),
         }
 
 def patch_to_dict(obj):
@@ -182,17 +190,18 @@ def patch_to_dict(obj):
     return \
         {
          'id'           : obj.id,
-         'date'         : str(obj.date),
+         'date'         : unicode(obj.date).encode("utf-8"),
          'filename'     : obj.filename(),
          'msgid'        : obj.msgid,
          'name'         : obj.name,
-         'project'      : str(obj.project),
+         'project'      : unicode(obj.project).encode("utf-8"),
          'project_id'   : obj.project_id,
-         'state'        : str(obj.state),
+         'state'        : unicode(obj.state).encode("utf-8"),
          'state_id'     : obj.state_id,
-         'submitter'    : str(obj.submitter),
+         'archived'     : obj.archived,
+         'submitter'    : unicode(obj.submitter).encode("utf-8"),
          'submitter_id' : obj.submitter_id,
-         'delegate'     : str(obj.delegate),
+         'delegate'     : unicode(obj.delegate).encode("utf-8"),
          'delegate_id'  : max(obj.delegate_id, 0),
          'commit_ref'   : max(obj.commit_ref, ''),
         }
@@ -291,12 +300,12 @@ def patch_list(filter={}):
             "project_id",
             "submitter_id",
             "delegate_id",
+            "archived",
             "state_id",
             "date",
             "commit_ref",
             "hash",
             "msgid",
-            "name",
             "max_count",
             ]
 
@@ -319,6 +328,9 @@ def patch_list(filter={}):
             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]
@@ -330,7 +342,7 @@ def patch_list(filter={}):
         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)
 
@@ -355,12 +367,22 @@ def patch_get_by_hash(hash):
     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 ""