def test_multiple_keys(self):
        """Test QueryDict with two key/value pairs with same keys."""

        q = QueryDict('vote=yes&vote=no')

        self.assertEqual(q['vote'], u'no')
        self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')

        self.assertEqual(q.get('vote', 'default'), u'no')
        self.assertEqual(q.get('foo', 'default'), 'default')
        self.assertEqual(q.getlist('vote'), [u'yes', u'no'])
        self.assertEqual(q.getlist('foo'), [])

        self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
        self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
        self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])

        self.assertEqual(q.has_key('vote'), True)
        self.assertEqual('vote' in q, True)
        self.assertEqual(q.has_key('foo'), False)
        self.assertEqual('foo' in q, False)
        self.assertEqual(q.items(), [(u'vote', u'no')])
        self.assertEqual(q.lists(), [(u'vote', [u'yes', u'no'])])
        self.assertEqual(q.keys(), [u'vote'])
        self.assertEqual(q.values(), [u'no'])
        self.assertEqual(len(q), 1)

        self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
        self.assertRaises(AttributeError, q.pop, 'foo')
        self.assertRaises(AttributeError, q.popitem)
        self.assertRaises(AttributeError, q.clear)
        self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
        self.assertRaises(AttributeError, q.__delitem__, 'vote')
Beispiel #2
0
def evaluations(request, application_id):
    application = Application.objects.get(pk=application_id)
    evaluator = request.user
    evaluation = Evaluation(evaluator=evaluator, application=application)
    evaluation.save()  # barf

    input = QueryDict(request.body)
    # todo: logic here should probably be in a Django Form model. Current form submitted is custom and could probably be
    # standardized
    eval_field_data = {}
    for k in input.keys():
        if k.startswith("comment-"):
            id = k.split("-")[1]
            if (id not in eval_field_data):
                eval_field_data[id] = {}
            eval_field_data[id]['comment'] = input[k]
        elif k.startswith("score-"):
            id = k.split("-")[1]
            if (id not in eval_field_data):
                eval_field_data[id] = {}
            eval_field_data[id]['score'] = input[k]

    for form_field_id in eval_field_data.keys():
        _id = FieldEntry.objects.get(pk=int(form_field_id))
        comment = eval_field_data[form_field_id]['comment']
        if eval_field_data[form_field_id]['score']:
            score = int(eval_field_data[form_field_id]['score'])
        eval_field = EvaluationField(evaluation=evaluation,
                                     form_field_entry=_id,
                                     comment=comment,
                                     score=score)
        eval_field.save()

    # request.body
    return render(request, 'snapp/evaluator_thank_you.html')
Beispiel #3
0
    def test_multiple_keys(self):
        """Test QueryDict with two key/value pairs with same keys."""

        q = QueryDict('vote=yes&vote=no')

        self.assertEqual(q['vote'], u'no')
        self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')

        self.assertEqual(q.get('vote', 'default'), u'no')
        self.assertEqual(q.get('foo', 'default'), 'default')
        self.assertEqual(q.getlist('vote'), [u'yes', u'no'])
        self.assertEqual(q.getlist('foo'), [])

        self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
        self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
        self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])

        self.assertEqual(q.has_key('vote'), True)
        self.assertEqual('vote' in q, True)
        self.assertEqual(q.has_key('foo'), False)
        self.assertEqual('foo' in q, False)
        self.assertEqual(q.items(), [(u'vote', u'no')])
        self.assertEqual(q.lists(), [(u'vote', [u'yes', u'no'])])
        self.assertEqual(q.keys(), [u'vote'])
        self.assertEqual(q.values(), [u'no'])
        self.assertEqual(len(q), 1)

        self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
        self.assertRaises(AttributeError, q.pop, 'foo')
        self.assertRaises(AttributeError, q.popitem)
        self.assertRaises(AttributeError, q.clear)
        self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
        self.assertRaises(AttributeError, q.__delitem__, 'vote')
Beispiel #4
0
    def test_multiple_keys(self):
        """Test QueryDict with two key/value pairs with same keys."""

        q = QueryDict("vote=yes&vote=no")

        self.assertEqual(q["vote"], u"no")
        self.assertRaises(AttributeError, q.__setitem__, "something", "bar")

        self.assertEqual(q.get("vote", "default"), u"no")
        self.assertEqual(q.get("foo", "default"), "default")
        self.assertEqual(q.getlist("vote"), [u"yes", u"no"])
        self.assertEqual(q.getlist("foo"), [])

        self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"])
        self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"])
        self.assertRaises(AttributeError, q.appendlist, "foo", ["bar"])

        self.assertEqual(q.has_key("vote"), True)
        self.assertEqual("vote" in q, True)
        self.assertEqual(q.has_key("foo"), False)
        self.assertEqual("foo" in q, False)
        self.assertEqual(q.items(), [(u"vote", u"no")])
        self.assertEqual(q.lists(), [(u"vote", [u"yes", u"no"])])
        self.assertEqual(q.keys(), [u"vote"])
        self.assertEqual(q.values(), [u"no"])
        self.assertEqual(len(q), 1)

        self.assertRaises(AttributeError, q.update, {"foo": "bar"})
        self.assertRaises(AttributeError, q.pop, "foo")
        self.assertRaises(AttributeError, q.popitem)
        self.assertRaises(AttributeError, q.clear)
        self.assertRaises(AttributeError, q.setdefault, "foo", "bar")
        self.assertRaises(AttributeError, q.__delitem__, "vote")
Beispiel #5
0
    def test_single_key_value(self):
        """Test QueryDict with one key/value pair"""

        q = QueryDict('foo=bar')
        self.assertEqual(q['foo'], 'bar')
        self.assertRaises(KeyError, q.__getitem__, 'bar')
        self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')

        self.assertEqual(q.get('foo', 'default'), 'bar')
        self.assertEqual(q.get('bar', 'default'), 'default')
        self.assertEqual(q.getlist('foo'), ['bar'])
        self.assertEqual(q.getlist('bar'), [])

        self.assertRaises(AttributeError, q.setlist, 'foo', ['bar'])
        self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])

        self.assertTrue(q.has_key('foo'))
        self.assertTrue('foo' in q)
        self.assertFalse(q.has_key('bar'))
        self.assertFalse('bar' in q)

        self.assertEqual(q.items(), [(u'foo', u'bar')])
        self.assertEqual(q.lists(), [(u'foo', [u'bar'])])
        self.assertEqual(q.keys(), ['foo'])
        self.assertEqual(q.values(), ['bar'])
        self.assertEqual(len(q), 1)

        self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
        self.assertRaises(AttributeError, q.pop, 'foo')
        self.assertRaises(AttributeError, q.popitem)
        self.assertRaises(AttributeError, q.clear)
        self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')

        self.assertEqual(q.urlencode(), 'foo=bar')
Beispiel #6
0
    def test_single_key_value(self):
        """Test QueryDict with one key/value pair"""

        q = QueryDict('foo=bar')
        self.assertEqual(q['foo'], 'bar')
        self.assertRaises(KeyError, q.__getitem__, 'bar')
        self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')

        self.assertEqual(q.get('foo', 'default'), 'bar')
        self.assertEqual(q.get('bar', 'default'), 'default')
        self.assertEqual(q.getlist('foo'), ['bar'])
        self.assertEqual(q.getlist('bar'), [])

        self.assertRaises(AttributeError, q.setlist, 'foo', ['bar'])
        self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])

        self.assertTrue(q.has_key('foo'))
        self.assertTrue('foo' in q)
        self.assertFalse(q.has_key('bar'))
        self.assertFalse('bar' in q)

        self.assertEqual(q.items(), [(u'foo', u'bar')])
        self.assertEqual(q.lists(), [(u'foo', [u'bar'])])
        self.assertEqual(q.keys(), ['foo'])
        self.assertEqual(q.values(), ['bar'])
        self.assertEqual(len(q), 1)

        self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
        self.assertRaises(AttributeError, q.pop, 'foo')
        self.assertRaises(AttributeError, q.popitem)
        self.assertRaises(AttributeError, q.clear)
        self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')

        self.assertEqual(q.urlencode(), 'foo=bar')
Beispiel #7
0
def evaluations(request, application_id):
    application = Application.objects.get(pk=application_id)
    evaluator = request.user
    evaluation = Evaluation(evaluator=evaluator, application=application)
    evaluation.save()  # barf

    input = QueryDict(request.body)
    # todo: logic here should probably be in a Django Form model. Current form submitted is custom and could probably be
    # standardized
    eval_field_data = {}
    for k in input.keys():
        if k.startswith("comment-"):
            id = k.split("-")[1]
            if id not in eval_field_data:
                eval_field_data[id] = {}
            eval_field_data[id]["comment"] = input[k]
        elif k.startswith("score-"):
            id = k.split("-")[1]
            if id not in eval_field_data:
                eval_field_data[id] = {}
            eval_field_data[id]["score"] = input[k]

    for form_field_id in eval_field_data.keys():
        _id = FieldEntry.objects.get(pk=int(form_field_id))
        comment = eval_field_data[form_field_id]["comment"]
        if eval_field_data[form_field_id]["score"]:
            score = int(eval_field_data[form_field_id]["score"])
        eval_field = EvaluationField(evaluation=evaluation, form_field_entry=_id, comment=comment, score=score)
        eval_field.save()

    # request.body
    return render(request, "snapp/evaluator_thank_you.html")
Beispiel #8
0
    def test_single_key_value(self):
        """Test QueryDict with one key/value pair"""

        q = QueryDict("foo=bar")
        self.assertEqual(q["foo"], "bar")
        self.assertRaises(KeyError, q.__getitem__, "bar")
        self.assertRaises(AttributeError, q.__setitem__, "something", "bar")

        self.assertEqual(q.get("foo", "default"), "bar")
        self.assertEqual(q.get("bar", "default"), "default")
        self.assertEqual(q.getlist("foo"), ["bar"])
        self.assertEqual(q.getlist("bar"), [])

        self.assertRaises(AttributeError, q.setlist, "foo", ["bar"])
        self.assertRaises(AttributeError, q.appendlist, "foo", ["bar"])

        self.assertTrue(q.has_key("foo"))
        self.assertTrue("foo" in q)
        self.assertFalse(q.has_key("bar"))
        self.assertFalse("bar" in q)

        self.assertEqual(q.items(), [(u"foo", u"bar")])
        self.assertEqual(q.lists(), [(u"foo", [u"bar"])])
        self.assertEqual(q.keys(), ["foo"])
        self.assertEqual(q.values(), ["bar"])
        self.assertEqual(len(q), 1)

        self.assertRaises(AttributeError, q.update, {"foo": "bar"})
        self.assertRaises(AttributeError, q.pop, "foo")
        self.assertRaises(AttributeError, q.popitem)
        self.assertRaises(AttributeError, q.clear)
        self.assertRaises(AttributeError, q.setdefault, "foo", "bar")

        self.assertEqual(q.urlencode(), "foo=bar")
Beispiel #9
0
 def parse_querydict(self, data: QueryDict, list_fields: List[str],
                     request: HttpRequest):
     result = {}
     for key in data.keys():
         if key in list_fields:
             result[key] = data.getlist(key)
         else:
             result[key] = data[key]
     return result
Beispiel #10
0
    def put(self, request, roll):
        try:
            put_req = QueryDict(request.body)
            obj = Student.objects.get(roll_no=roll)

            if 'first_name' in put_req.keys():
                obj.first_name = put_req['first_name']
            if 'last_name' in put_req.keys():
                obj.last_name = put_req['last_name']
            if 'email' in put_req.keys():
                obj.email = put_req['email']
            if 'college_name' in put_req.keys():
                obj.college_name = put_req['college_name']

            obj.save()
            return HttpResponse("successfully Updated ", status=200)
        except ObjectDoesNotExist:
            return HttpResponse(' Object does not exist', status=500)
Beispiel #11
0
def _querydict_to_dict(cls, data: QueryDict):
    list_fields = getattr(cls, "_collection_fields", [])
    result = {}
    for key in data.keys():
        if key in list_fields:
            result[key] = data.getlist(key)
        else:
            result[key] = data[key]
    return result
Beispiel #12
0
def getTree(request):
    params = QueryDict(request.META['QUERY_STRING'])
    if('family' in params.keys()):
        g = GraphConnection()
        attributes = {'family': params['family']}
        result = g.getFamily(attributes)
        return HttpResponse(content=json.dumps(result), status=200)
    else:
        return HttpResponse(content='failed', status=404)
Beispiel #13
0
def is_empty_query(data: QueryDict):
    """検索条件が空かどうか"""
    for key in data.keys():
        # どれでも値があればOK
        values = data.getlist(key)
        for value in values:
            if value:
                return False

    return True
Beispiel #14
0
 def test_immutable_basic_operations(self):
     q = QueryDict()
     self.assertEqual(q.getlist('foo'), [])
     self.assertNotIn('foo', q)
     self.assertEqual(list(q.items()), [])
     self.assertEqual(list(q.lists()), [])
     self.assertEqual(list(q.keys()), [])
     self.assertEqual(list(q.values()), [])
     self.assertEqual(len(q), 0)
     self.assertEqual(q.urlencode(), '')
Beispiel #15
0
 def test_immutable_basic_operations(self):
     q = QueryDict('')
     self.assertEqual(q.getlist('foo'), [])
     self.assertEqual(q.has_key('foo'), False)
     self.assertEqual('foo' in q, False)
     self.assertEqual(q.items(), [])
     self.assertEqual(q.lists(), [])
     self.assertEqual(q.items(), [])
     self.assertEqual(q.keys(), [])
     self.assertEqual(q.values(), [])
     self.assertEqual(len(q), 0)
     self.assertEqual(q.urlencode(), '')
Beispiel #16
0
 def test_immutable_basic_operations(self):
     q = QueryDict('')
     self.assertEqual(q.getlist('foo'), [])
     self.assertEqual(q.has_key('foo'), False)
     self.assertEqual('foo' in q, False)
     self.assertEqual(q.items(), [])
     self.assertEqual(q.lists(), [])
     self.assertEqual(q.items(), [])
     self.assertEqual(q.keys(), [])
     self.assertEqual(q.values(), [])
     self.assertEqual(len(q), 0)
     self.assertEqual(q.urlencode(), '')
    def put(self, request):  # - Edit a task (PUT /tasks/<task_id>/)
        # http://127.0.0.1:8000/Notes/tasks/?id=3
        try:
            id = int(request.GET.get('id'))
            entry = Task.objects.get(taskId=id)

            taskDetails = QueryDict(request.body)
            if not taskDetails:
                return HttpResponse(
                    'Please provide something to change. Attributes can be given in the same format as in POST',
                    status=200)

            if 'title' in taskDetails.keys():
                entry.title = taskDetails['title']
            if 'desc' in taskDetails.keys():
                entry.description = taskDetails['desc']
            if 'label' in taskDetails.keys():
                entry.label = taskDetails['label']
            if 'color' in taskDetails.keys():
                entry.color = taskDetails['color']
            if 'comments' in taskDetails.keys():
                entry.comments = taskDetails['comments']
            if 'due' in taskDetails.keys():
                entry.dueDate = taskDetails['due']

            entry.save()
            return HttpResponse('Task Updated Successfully', status=201)
        except Task.DoesNotExist as e:
            return HttpResponse("Task Not Found. Therefore cannot be updated",
                                status=400)
        except Exception as e:
            return HttpResponse(e, status=400)
 def wrap(request, *args, **kwargs):
     data = QueryDict(request.body)
     if 'pid' not in data.keys():
         return func(request, *args, **kwargs)
     else:
         try:
             prj = Project.objects.get(pk=data['pid'])
         except ObjectDoesNotExist:
             return HttpResponse("{'status':'error', 'reason':'cannot find a project matching given pid'}")
         else:
             if request.user == prj.author or request.user in prj.collaborators:
                 return func(request, *args, **kwargs)
             else:
                 return HttpResponse("{'status':'error', 'reason':'the project cannot match the user logged in'}")
 def wrap(request, *args, **kwargs):
     data = QueryDict(request.body)
     if "pid" not in data.keys():
         return func(request, *args, **kwargs)
     else:
         try:
             prj = ProjectFile.objects.get(pk=ObjectId(data["pid"]))
         except ObjectDoesNotExist:
             return HttpResponse('{"status":"error", "reason":"cannot find a project matching given pid"}')
         else:
             if request.user == prj.author or request.user in prj.collaborators:
                 return func(request, *args, **kwargs)
             else:
                 return HttpResponse('{"status":"error", "reason":"the project cannot match the user logged in"}')
Beispiel #20
0
def updateDetails(request, videoKey):
    if request.method == 'POST':
        q = QueryDict(request.body).copy()
        q.pop('csrfmiddlewaretoken')
        params = {}
        for x in q.keys():
            params[x] = q[x]

        resp = jwAccount.videos.update(video_key=videoKey, **params)

        if resp['status'] == 'ok':
            print('success')
            return HttpResponse('success')
        else:
            print('fail')
            return HttpResponse('fail')
Beispiel #21
0
    def patch(self, request, *args, **kwargs):
        data_dict = request.data
        mutable_query_dict = QueryDict(mutable=True)
        mutable_query_dict.update(data_dict)
        mutable_query_dict.__setitem__('user_id', request.user.id)

        instance = self.get_object()

        if 'custom_search_view' in mutable_query_dict.keys():
            custom_search_query_fe = mutable_query_dict.__getitem__(
                'custom_search_view')
            custom_search_query = fe_to_be_url(custom_search_query_fe)

            query_hash_digest = hashlib.sha256(
                custom_search_query.encode('utf-8')).hexdigest()

            try:
                result_hash_length = get_query_result_hash_and_length(
                    custom_search_query)
                result_hash = result_hash_length['hash']
            except Exception as e:
                Response('The query submitted is not valid',
                         status=status.HTTP_422_UNPROCESSABLE_ENTITY)

            if u.CustomSearch.objects.filter(
                    query_string_hash_digest=query_hash_digest).exists():
                custom_search = u.CustomSearch.objects.get(
                    query_string_hash_digest=query_hash_digest)
            else:
                custom_search = u.CustomSearch(
                    frontend_url=custom_search_query_fe,
                    query_string=custom_search_query,
                    result_hash_digest=result_hash)
                custom_search.save()
            mutable_query_dict.__setitem__('custom_search_view',
                                           custom_search.id)
            mutable_query_dict.__setitem__('last_notified_hash',
                                           custom_search.result_hash_digest)
            mutable_query_dict.__setitem__('last_number_of_results',
                                           result_hash_length['length'])

        serializer = self.get_serializer(instance, data=mutable_query_dict)
        serializer.is_valid(raise_exception=True)
        serializer.save()

        return Response(serializer.data, status=status.HTTP_200_OK)
 def wrap(request, *args, **kwargs):
     data = QueryDict(request.body)
     if 'pid' not in data.keys():
         return func(request, *args, **kwargs)
     else:
         try:
             prj = Project.objects.get(pk=data['pid'])
         except ObjectDoesNotExist:
             return HttpResponse(
                 "{'status':'error', 'reason':'cannot find a project matching given pid'}"
             )
         else:
             if request.user == prj.author or request.user in prj.collaborators:
                 return func(request, *args, **kwargs)
             else:
                 return HttpResponse(
                     "{'status':'error', 'reason':'the project cannot match the user logged in'}"
                 )
Beispiel #23
0
    def test_single_key_value(self):
        """Test QueryDict with one key/value pair"""

        q = QueryDict('foo=bar')
        self.assertEqual(q['foo'], 'bar')
        with self.assertRaises(KeyError):
            q.__getitem__('bar')
        with self.assertRaises(AttributeError):
            q.__setitem__('something', 'bar')

        self.assertEqual(q.get('foo', 'default'), 'bar')
        self.assertEqual(q.get('bar', 'default'), 'default')
        self.assertEqual(q.getlist('foo'), ['bar'])
        self.assertEqual(q.getlist('bar'), [])

        with self.assertRaises(AttributeError):
            q.setlist('foo', ['bar'])
        with self.assertRaises(AttributeError):
            q.appendlist('foo', ['bar'])

        self.assertIn('foo', q)
        self.assertNotIn('bar', q)

        self.assertEqual(list(q), ['foo'])
        self.assertEqual(list(q.items()), [('foo', 'bar')])
        self.assertEqual(list(q.lists()), [('foo', ['bar'])])
        self.assertEqual(list(q.keys()), ['foo'])
        self.assertEqual(list(q.values()), ['bar'])
        self.assertEqual(len(q), 1)

        with self.assertRaises(AttributeError):
            q.update({'foo': 'bar'})
        with self.assertRaises(AttributeError):
            q.pop('foo')
        with self.assertRaises(AttributeError):
            q.popitem()
        with self.assertRaises(AttributeError):
            q.clear()
        with self.assertRaises(AttributeError):
            q.setdefault('foo', 'bar')

        self.assertEqual(q.urlencode(), 'foo=bar')
Beispiel #24
0
    def test_single_key_value(self):
        """Test QueryDict with one key/value pair"""

        q = QueryDict("foo=bar")
        self.assertEqual(q["foo"], "bar")
        with self.assertRaises(KeyError):
            q.__getitem__("bar")
        with self.assertRaises(AttributeError):
            q.__setitem__("something", "bar")

        self.assertEqual(q.get("foo", "default"), "bar")
        self.assertEqual(q.get("bar", "default"), "default")
        self.assertEqual(q.getlist("foo"), ["bar"])
        self.assertEqual(q.getlist("bar"), [])

        with self.assertRaises(AttributeError):
            q.setlist("foo", ["bar"])
        with self.assertRaises(AttributeError):
            q.appendlist("foo", ["bar"])

        self.assertIn("foo", q)
        self.assertNotIn("bar", q)

        self.assertEqual(list(q), ["foo"])
        self.assertEqual(list(q.items()), [("foo", "bar")])
        self.assertEqual(list(q.lists()), [("foo", ["bar"])])
        self.assertEqual(list(q.keys()), ["foo"])
        self.assertEqual(list(q.values()), ["bar"])
        self.assertEqual(len(q), 1)

        with self.assertRaises(AttributeError):
            q.update({"foo": "bar"})
        with self.assertRaises(AttributeError):
            q.pop("foo")
        with self.assertRaises(AttributeError):
            q.popitem()
        with self.assertRaises(AttributeError):
            q.clear()
        with self.assertRaises(AttributeError):
            q.setdefault("foo", "bar")

        self.assertEqual(q.urlencode(), "foo=bar")
Beispiel #25
0
    def test_multiple_keys(self):
        """Test QueryDict with two key/value pairs with same keys."""

        q = QueryDict('vote=yes&vote=no')

        self.assertEqual(q['vote'], 'no')
        with self.assertRaises(AttributeError):
            q.__setitem__('something', 'bar')

        self.assertEqual(q.get('vote', 'default'), 'no')
        self.assertEqual(q.get('foo', 'default'), 'default')
        self.assertEqual(q.getlist('vote'), ['yes', 'no'])
        self.assertEqual(q.getlist('foo'), [])

        with self.assertRaises(AttributeError):
            q.setlist('foo', ['bar', 'baz'])
        with self.assertRaises(AttributeError):
            q.setlist('foo', ['bar', 'baz'])
        with self.assertRaises(AttributeError):
            q.appendlist('foo', ['bar'])

        self.assertIn('vote', q)
        self.assertNotIn('foo', q)
        self.assertEqual(list(q), ['vote'])
        self.assertEqual(list(q.items()), [('vote', 'no')])
        self.assertEqual(list(q.lists()), [('vote', ['yes', 'no'])])
        self.assertEqual(list(q.keys()), ['vote'])
        self.assertEqual(list(q.values()), ['no'])
        self.assertEqual(len(q), 1)

        with self.assertRaises(AttributeError):
            q.update({'foo': 'bar'})
        with self.assertRaises(AttributeError):
            q.pop('foo')
        with self.assertRaises(AttributeError):
            q.popitem()
        with self.assertRaises(AttributeError):
            q.clear()
        with self.assertRaises(AttributeError):
            q.setdefault('foo', 'bar')
        with self.assertRaises(AttributeError):
            q.__delitem__('vote')
Beispiel #26
0
    def test_multiple_keys(self):
        """Test QueryDict with two key/value pairs with same keys."""

        q = QueryDict("vote=yes&vote=no")

        self.assertEqual(q["vote"], "no")
        with self.assertRaises(AttributeError):
            q.__setitem__("something", "bar")

        self.assertEqual(q.get("vote", "default"), "no")
        self.assertEqual(q.get("foo", "default"), "default")
        self.assertEqual(q.getlist("vote"), ["yes", "no"])
        self.assertEqual(q.getlist("foo"), [])

        with self.assertRaises(AttributeError):
            q.setlist("foo", ["bar", "baz"])
        with self.assertRaises(AttributeError):
            q.setlist("foo", ["bar", "baz"])
        with self.assertRaises(AttributeError):
            q.appendlist("foo", ["bar"])

        self.assertIn("vote", q)
        self.assertNotIn("foo", q)
        self.assertEqual(list(q), ["vote"])
        self.assertEqual(list(q.items()), [("vote", "no")])
        self.assertEqual(list(q.lists()), [("vote", ["yes", "no"])])
        self.assertEqual(list(q.keys()), ["vote"])
        self.assertEqual(list(q.values()), ["no"])
        self.assertEqual(len(q), 1)

        with self.assertRaises(AttributeError):
            q.update({"foo": "bar"})
        with self.assertRaises(AttributeError):
            q.pop("foo")
        with self.assertRaises(AttributeError):
            q.popitem()
        with self.assertRaises(AttributeError):
            q.clear()
        with self.assertRaises(AttributeError):
            q.setdefault("foo", "bar")
        with self.assertRaises(AttributeError):
            q.__delitem__("vote")
Beispiel #27
0
    def test_single_key_value(self):
        """Test QueryDict with one key/value pair"""

        q = QueryDict('foo=bar')
        self.assertEqual(q['foo'], 'bar')
        with self.assertRaises(KeyError):
            q.__getitem__('bar')
        with self.assertRaises(AttributeError):
            q.__setitem__('something', 'bar')

        self.assertEqual(q.get('foo', 'default'), 'bar')
        self.assertEqual(q.get('bar', 'default'), 'default')
        self.assertEqual(q.getlist('foo'), ['bar'])
        self.assertEqual(q.getlist('bar'), [])

        with self.assertRaises(AttributeError):
            q.setlist('foo', ['bar'])
        with self.assertRaises(AttributeError):
            q.appendlist('foo', ['bar'])

        self.assertIn('foo', q)
        self.assertNotIn('bar', q)

        self.assertEqual(list(q), ['foo'])
        self.assertEqual(list(q.items()), [('foo', 'bar')])
        self.assertEqual(list(q.lists()), [('foo', ['bar'])])
        self.assertEqual(list(q.keys()), ['foo'])
        self.assertEqual(list(q.values()), ['bar'])
        self.assertEqual(len(q), 1)

        with self.assertRaises(AttributeError):
            q.update({'foo': 'bar'})
        with self.assertRaises(AttributeError):
            q.pop('foo')
        with self.assertRaises(AttributeError):
            q.popitem()
        with self.assertRaises(AttributeError):
            q.clear()
        with self.assertRaises(AttributeError):
            q.setdefault('foo', 'bar')

        self.assertEqual(q.urlencode(), 'foo=bar')
Beispiel #28
0
class URL(object):
    def __init__(self,
                 path=None,
                 query_string=None,
                 query=None,
                 viewname=None):
        if viewname:
            path = reverse(viewname=viewname)
        self._path = path
        self._query_string = query_string
        self._query = query

        kwargs = {'mutable': True}
        if self._query_string:
            kwargs['query_string'] = self._query_string.encode('utf-8')

        self._args = QueryDict(**kwargs)

        if self._query:
            self.args.update(self._query)

    @property
    def args(self):
        return self._args

    def to_string(self):
        if self._args.keys():
            query = '?{}'.format(self._args.urlencode())
        else:
            query = ''

        if self._path:
            path = self._path
        else:
            path = ''

        result = '{}{}'.format(path, query)

        if PY3:
            return result
        else:
            return force_bytes(result)
Beispiel #29
0
    def test_multiple_keys(self):
        """Test QueryDict with two key/value pairs with same keys."""

        q = QueryDict('vote=yes&vote=no')

        self.assertEqual(q['vote'], 'no')
        with self.assertRaises(AttributeError):
            q.__setitem__('something', 'bar')

        self.assertEqual(q.get('vote', 'default'), 'no')
        self.assertEqual(q.get('foo', 'default'), 'default')
        self.assertEqual(q.getlist('vote'), ['yes', 'no'])
        self.assertEqual(q.getlist('foo'), [])

        with self.assertRaises(AttributeError):
            q.setlist('foo', ['bar', 'baz'])
        with self.assertRaises(AttributeError):
            q.setlist('foo', ['bar', 'baz'])
        with self.assertRaises(AttributeError):
            q.appendlist('foo', ['bar'])

        self.assertIn('vote', q)
        self.assertNotIn('foo', q)
        self.assertEqual(list(q), ['vote'])
        self.assertEqual(list(q.items()), [('vote', 'no')])
        self.assertEqual(list(q.lists()), [('vote', ['yes', 'no'])])
        self.assertEqual(list(q.keys()), ['vote'])
        self.assertEqual(list(q.values()), ['no'])
        self.assertEqual(len(q), 1)

        with self.assertRaises(AttributeError):
            q.update({'foo': 'bar'})
        with self.assertRaises(AttributeError):
            q.pop('foo')
        with self.assertRaises(AttributeError):
            q.popitem()
        with self.assertRaises(AttributeError):
            q.clear()
        with self.assertRaises(AttributeError):
            q.setdefault('foo', 'bar')
        with self.assertRaises(AttributeError):
            q.__delitem__('vote')
Beispiel #30
0
    def test_basic_mutable_operations(self):
        q = QueryDict(mutable=True)
        q["name"] = "john"
        self.assertEqual(q.get("foo", "default"), "default")
        self.assertEqual(q.get("name", "default"), "john")
        self.assertEqual(q.getlist("name"), ["john"])
        self.assertEqual(q.getlist("foo"), [])

        q.setlist("foo", ["bar", "baz"])
        self.assertEqual(q.get("foo", "default"), "baz")
        self.assertEqual(q.getlist("foo"), ["bar", "baz"])

        q.appendlist("foo", "another")
        self.assertEqual(q.getlist("foo"), ["bar", "baz", "another"])
        self.assertEqual(q["foo"], "another")
        self.assertIn("foo", q)

        self.assertCountEqual(q, ["foo", "name"])
        self.assertCountEqual(q.items(), [("foo", "another"),
                                          ("name", "john")])
        self.assertCountEqual(q.lists(), [("foo", ["bar", "baz", "another"]),
                                          ("name", ["john"])])
        self.assertCountEqual(q.keys(), ["foo", "name"])
        self.assertCountEqual(q.values(), ["another", "john"])

        q.update({"foo": "hello"})
        self.assertEqual(q["foo"], "hello")
        self.assertEqual(q.get("foo", "not available"), "hello")
        self.assertEqual(q.getlist("foo"), ["bar", "baz", "another", "hello"])
        self.assertEqual(q.pop("foo"), ["bar", "baz", "another", "hello"])
        self.assertEqual(q.pop("foo", "not there"), "not there")
        self.assertEqual(q.get("foo", "not there"), "not there")
        self.assertEqual(q.setdefault("foo", "bar"), "bar")
        self.assertEqual(q["foo"], "bar")
        self.assertEqual(q.getlist("foo"), ["bar"])
        self.assertIn(q.urlencode(),
                      ["foo=bar&name=john", "name=john&foo=bar"])

        q.clear()
        self.assertEqual(len(q), 0)
Beispiel #31
0
    def test_basic_mutable_operations(self):
        q = QueryDict('').copy()
        q['name'] = 'john'
        self.assertEqual(q.get('foo', 'default'), 'default')
        self.assertEqual(q.get('name', 'default'), 'john')
        self.assertEqual(q.getlist('name'), ['john'])
        self.assertEqual(q.getlist('foo'), [])

        q.setlist('foo', ['bar', 'baz'])
        self.assertEqual(q.get('foo', 'default'), 'baz')
        self.assertEqual(q.getlist('foo'), ['bar', 'baz'])

        q.appendlist('foo', 'another')
        self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another'])
        self.assertEqual(q['foo'], 'another')
        self.failUnless(q.has_key('foo'))
        self.failUnless('foo' in q)

        self.assertEqual(q.items(), [(u'foo', u'another'), (u'name', u'john')])
        self.assertEqual(q.lists(), [(u'foo', [u'bar', u'baz', u'another']),
                                     (u'name', [u'john'])])
        self.assertEqual(q.keys(), [u'foo', u'name'])
        self.assertEqual(q.values(), [u'another', u'john'])
        self.assertEqual(len(q), 2)

        q.update({'foo': 'hello'})
        self.assertEqual(q['foo'], 'hello')
        self.assertEqual(q.get('foo', 'not available'), 'hello')
        self.assertEqual(q.getlist('foo'),
                         [u'bar', u'baz', u'another', u'hello'])
        self.assertEqual(q.pop('foo'), [u'bar', u'baz', u'another', u'hello'])
        self.assertEqual(q.pop('foo', 'not there'), 'not there')
        self.assertEqual(q.get('foo', 'not there'), 'not there')
        self.assertEqual(q.setdefault('foo', 'bar'), 'bar')
        self.assertEqual(q['foo'], 'bar')
        self.assertEqual(q.getlist('foo'), ['bar'])
        self.assertEqual(q.urlencode(), 'foo=bar&name=john')

        q.clear()
        self.assertEqual(len(q), 0)
Beispiel #32
0
    def test_basic_mutable_operations(self):
        q = QueryDict(mutable=True)
        q['name'] = 'john'
        self.assertEqual(q.get('foo', 'default'), 'default')
        self.assertEqual(q.get('name', 'default'), 'john')
        self.assertEqual(q.getlist('name'), ['john'])
        self.assertEqual(q.getlist('foo'), [])

        q.setlist('foo', ['bar', 'baz'])
        self.assertEqual(q.get('foo', 'default'), 'baz')
        self.assertEqual(q.getlist('foo'), ['bar', 'baz'])

        q.appendlist('foo', 'another')
        self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another'])
        self.assertEqual(q['foo'], 'another')
        self.assertIn('foo', q)

        self.assertCountEqual(q, ['foo', 'name'])
        self.assertCountEqual(q.items(), [('foo', 'another'),
                                          ('name', 'john')])
        self.assertCountEqual(q.lists(), [('foo', ['bar', 'baz', 'another']),
                                          ('name', ['john'])])
        self.assertCountEqual(q.keys(), ['foo', 'name'])
        self.assertCountEqual(q.values(), ['another', 'john'])

        q.update({'foo': 'hello'})
        self.assertEqual(q['foo'], 'hello')
        self.assertEqual(q.get('foo', 'not available'), 'hello')
        self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another', 'hello'])
        self.assertEqual(q.pop('foo'), ['bar', 'baz', 'another', 'hello'])
        self.assertEqual(q.pop('foo', 'not there'), 'not there')
        self.assertEqual(q.get('foo', 'not there'), 'not there')
        self.assertEqual(q.setdefault('foo', 'bar'), 'bar')
        self.assertEqual(q['foo'], 'bar')
        self.assertEqual(q.getlist('foo'), ['bar'])
        self.assertIn(q.urlencode(),
                      ['foo=bar&name=john', 'name=john&foo=bar'])

        q.clear()
        self.assertEqual(len(q), 0)
Beispiel #33
0
    def test_basic_mutable_operations(self):
        q = QueryDict('').copy()
        q['name'] = 'john'
        self.assertEqual(q.get('foo', 'default'), 'default')
        self.assertEqual(q.get('name', 'default'), 'john')
        self.assertEqual(q.getlist('name'), ['john'])
        self.assertEqual(q.getlist('foo'), [])

        q.setlist('foo', ['bar', 'baz'])
        self.assertEqual(q.get('foo', 'default'), 'baz')
        self.assertEqual(q.getlist('foo'), ['bar', 'baz'])

        q.appendlist('foo', 'another')
        self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another'])
        self.assertEqual(q['foo'], 'another')
        self.assertTrue(q.has_key('foo'))
        self.assertTrue('foo' in q)

        self.assertEqual(q.items(),  [(u'foo', u'another'), (u'name', u'john')])
        self.assertEqual(q.lists(), [(u'foo', [u'bar', u'baz', u'another']), (u'name', [u'john'])])
        self.assertEqual(q.keys(), [u'foo', u'name'])
        self.assertEqual(q.values(), [u'another', u'john'])
        self.assertEqual(len(q), 2)

        q.update({'foo': 'hello'})
        self.assertEqual(q['foo'], 'hello')
        self.assertEqual(q.get('foo', 'not available'), 'hello')
        self.assertEqual(q.getlist('foo'), [u'bar', u'baz', u'another', u'hello'])
        self.assertEqual(q.pop('foo'), [u'bar', u'baz', u'another', u'hello'])
        self.assertEqual(q.pop('foo', 'not there'), 'not there')
        self.assertEqual(q.get('foo', 'not there'), 'not there')
        self.assertEqual(q.setdefault('foo', 'bar'), 'bar')
        self.assertEqual(q['foo'], 'bar')
        self.assertEqual(q.getlist('foo'), ['bar'])
        self.assertEqual(q.urlencode(), 'foo=bar&name=john')

        q.clear()
        self.assertEqual(len(q), 0)
Beispiel #34
0
    def test_basic_mutable_operations(self):
        q = QueryDict("").copy()
        q["name"] = "john"
        self.assertEqual(q.get("foo", "default"), "default")
        self.assertEqual(q.get("name", "default"), "john")
        self.assertEqual(q.getlist("name"), ["john"])
        self.assertEqual(q.getlist("foo"), [])

        q.setlist("foo", ["bar", "baz"])
        self.assertEqual(q.get("foo", "default"), "baz")
        self.assertEqual(q.getlist("foo"), ["bar", "baz"])

        q.appendlist("foo", "another")
        self.assertEqual(q.getlist("foo"), ["bar", "baz", "another"])
        self.assertEqual(q["foo"], "another")
        self.assertTrue(q.has_key("foo"))
        self.assertTrue("foo" in q)

        self.assertEqual(q.items(), [(u"foo", u"another"), (u"name", u"john")])
        self.assertEqual(q.lists(), [(u"foo", [u"bar", u"baz", u"another"]), (u"name", [u"john"])])
        self.assertEqual(q.keys(), [u"foo", u"name"])
        self.assertEqual(q.values(), [u"another", u"john"])
        self.assertEqual(len(q), 2)

        q.update({"foo": "hello"})
        self.assertEqual(q["foo"], "hello")
        self.assertEqual(q.get("foo", "not available"), "hello")
        self.assertEqual(q.getlist("foo"), [u"bar", u"baz", u"another", u"hello"])
        self.assertEqual(q.pop("foo"), [u"bar", u"baz", u"another", u"hello"])
        self.assertEqual(q.pop("foo", "not there"), "not there")
        self.assertEqual(q.get("foo", "not there"), "not there")
        self.assertEqual(q.setdefault("foo", "bar"), "bar")
        self.assertEqual(q["foo"], "bar")
        self.assertEqual(q.getlist("foo"), ["bar"])
        self.assertEqual(q.urlencode(), "foo=bar&name=john")

        q.clear()
        self.assertEqual(len(q), 0)
Beispiel #35
0
def get_query_params(
        query_params: QueryDict,
        param_getter_map: Dict[str, Callable[[QueryDict],
                                             Any]]) -> Dict[str, Any]:
    unexpected_params = set(query_params.keys()) - set(param_getter_map.keys())
    if unexpected_params:
        raise exceptions.ValidationError(
            detail=f'unexpected params: {unexpected_params}')

    res = {}
    errs = []
    for param_key in param_getter_map.keys():
        if param_key not in query_params:
            continue
        try:
            res[param_key] = param_getter_map[param_key](query_params)
        except Exception:
            errs.append(param_key)

    if errs:
        raise exceptions.ValidationError(detail=f'invalid parameters: {errs}')

    return res
Beispiel #36
0
    def test_basic_mutable_operations(self):
        q = QueryDict(mutable=True)
        q['name'] = 'john'
        self.assertEqual(q.get('foo', 'default'), 'default')
        self.assertEqual(q.get('name', 'default'), 'john')
        self.assertEqual(q.getlist('name'), ['john'])
        self.assertEqual(q.getlist('foo'), [])

        q.setlist('foo', ['bar', 'baz'])
        self.assertEqual(q.get('foo', 'default'), 'baz')
        self.assertEqual(q.getlist('foo'), ['bar', 'baz'])

        q.appendlist('foo', 'another')
        self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another'])
        self.assertEqual(q['foo'], 'another')
        self.assertIn('foo', q)

        self.assertCountEqual(q, ['foo', 'name'])
        self.assertCountEqual(q.items(), [('foo', 'another'), ('name', 'john')])
        self.assertCountEqual(q.lists(), [('foo', ['bar', 'baz', 'another']), ('name', ['john'])])
        self.assertCountEqual(q.keys(), ['foo', 'name'])
        self.assertCountEqual(q.values(), ['another', 'john'])

        q.update({'foo': 'hello'})
        self.assertEqual(q['foo'], 'hello')
        self.assertEqual(q.get('foo', 'not available'), 'hello')
        self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another', 'hello'])
        self.assertEqual(q.pop('foo'), ['bar', 'baz', 'another', 'hello'])
        self.assertEqual(q.pop('foo', 'not there'), 'not there')
        self.assertEqual(q.get('foo', 'not there'), 'not there')
        self.assertEqual(q.setdefault('foo', 'bar'), 'bar')
        self.assertEqual(q['foo'], 'bar')
        self.assertEqual(q.getlist('foo'), ['bar'])
        self.assertIn(q.urlencode(), ['foo=bar&name=john', 'name=john&foo=bar'])

        q.clear()
        self.assertEqual(len(q), 0)
Beispiel #37
0
def querystring(qsdict, extra=None):
    qs = QueryDict("").copy()
    qs.update(qsdict)
    if extra:
        extra = re.sub('\s', '', extra)
        for bit in extra.split("&"):
            if bit:
                k, v = bit.split("=")
                if v:
                    qs[k] = v
                elif k in qs:
                    del(qs[k])
    # remove pointless click coordinates from image submit buttons
    # (could be a problem if you have legit 'x' and 'y' vars!)
    if 'x' in qs:
        del(qs['x'])
    if 'y' in qs:
        del(qs['y'])
    for k in qs.keys():
        if isinstance(qs[k], bool):
            qs[k] = 1 if qs[k] else 0
        elif qs[k] is None:
            del(qs[k])
    return qs.urlencode()
Beispiel #38
0
def querystring(qsdict, extra=None):
    qs = QueryDict("").copy()
    qs.update(qsdict)
    if extra:
        extra = re.sub('\s', '', extra)
        for bit in extra.split("&"):
            if bit:
                k, v = bit.split("=")
                if v:
                    qs[k] = v
                elif k in qs:
                    del (qs[k])
    # remove pointless click coordinates from image submit buttons
    # (could be a problem if you have legit 'x' and 'y' vars!)
    if 'x' in qs:
        del (qs['x'])
    if 'y' in qs:
        del (qs['y'])
    for k in qs.keys():
        if isinstance(qs[k], bool):
            qs[k] = 1 if qs[k] else 0
        elif qs[k] is None:
            del (qs[k])
    return qs.urlencode()
Beispiel #39
0
def get_del_addref_link(request, **kwargs):
    """ A RESTful api that user can get/delete and make a copy using different method

    Following are the mapping between method and operation:
        1. GET: return all infomation of the link asked.
        2. DELETE: delete the specific node if the logged-in user has access to do so.
        3. PUT: make a copy(actually a ref) that belongs to the project which the user is working on.
        4. PATCH: merely modify the x, y coordinates of specific node

    @param kwargs: kwarg['id'] is the object_id or ref_id
    @param request: django request object
    @type request: django.http.request
    @return: success prompt or error information
    """
    if request.method == 'DELETE':
        '''
            DELETE A REF IN COLLECTION<link_ref>
        '''

        linkref = db.link_ref.find_one({'_id': ObjectId(kwargs['id'])})

        # not found
        if linkref is None:
            return HttpResponse("{'status':'error', 'reason':'no record match that id'}")

        # remove ref in specific node record
        db.link.update({'_id': linkref['link_id']}, {'$pull', {"link_refs", linkref['_id']}})

        # remove node_ref record
        db.link_ref.remove({'_id': linkref['_id']})

        return HttpResponse("{'status': 'success'}")

    elif request.method == 'PUT':
        '''
            add a ref record in collection <node_ref>
        '''
        paras = QueryDict(request.body)
        try:
            link = db.link.find_one({'_id': ObjectId(kwargs['id'])})
        except KeyError:
            return HttpResponse("{'status':'error', 'reason':'key <_id> does not exist'}")

        # not found
        if link is None:
            return HttpResponse("{'status':'error', 'reason':'object not found'}")

        # link exists
        linkref_id = db.link_ref.insert(
            {
                'pid': int(paras['pid']) if 'pid' in paras.keys() else 0,
                'link_id': paras['_id'],
                'id1': ObjectId(paras['id1']),
                'id2': ObjectId(paras['id2'])
            }
        )
        if linkref_id:
            prj_id = db.project.find_one({'pid': int(QueryDict(request.body)['pid'])})
            if prj_id is None:
                prj_id = db.project.insert({'pid': int(QueryDict(request.body)['pid']), 'node': [], 'link': []})
                prj_id = db.project.find_one({'_id': prj_id})
            else:
                pass
            db.project.update({'_id': prj_id['_id']}, {'$push': {'link': linkref_id}}, True)


            data = {'status': 'success', 'ref_id': str(linkref_id)}
            return HttpResponse(json.dumps(data))
        else:
            return HttpResponse("{'status':'error', 'reason':'insert failed'}")

    elif request.method == 'GET':
        '''
        get the detail info of a record
        '''
        try:
            link = db.link.find_one({'_id': ObjectId(kwargs['id'])})
        except KeyError:
            return HttpResponse("{'status':'error', 'reason':'key <_id> does not exist'}")

        if link is None:
            # not found
            return HttpResponse("{'status':'error', 'reason':'object not found'}")

        else:
            # the node exists
            link_dic = link
            for key in link_dic.keys():
                if isinstance(link_dic[key], bson.objectid.ObjectId):
                    link_dic[key] = str(link_dic[key])
                if (isinstance(link_dic[key], list) and len(link_dic[key]) > 0 and
                        isinstance(link_dic[key][0], ObjectId)):
                    newrefs = []
                    for refid in link_dic[key]:
                        newrefs.append(str(refid))
                    link_dic[key] = newrefs

            return HttpResponse(json.dumps(link_dic))

    else:
        # method incorrect
        return HttpResponse("{'status': 'error','reason':'pls use method DELETE/PUT '}")
Beispiel #40
0
def build_query(querystring, queryset_modifier_fn=None):
    query_params = QueryDict(querystring)
    normalized = normalize_querystring(query_params)
    if normalized != querystring:
        raise NonNormalQuerystring(normalized)
    querystring = normalized

    base_user_query = CoreUser.objects.using("ak").order_by("id")
    
    includes = []

    include_pattern = re.compile("^include:\d+$")
    for key in query_params.keys():
        if (include_pattern.match(key)
            and query_params[key]
            and (not query_params[key].endswith('_istoggle'))):
            includes.append((key, query_params.getlist(key)))

    human_query = []

    all_user_queries = []
    for include_group in includes:
        users = base_user_query
        _human_query = []
        for item in include_group[1]:
            ## "distance" is handled in a group with "zipcode", so we ignore it here
            if item == "zipcode__distance":
                continue
            ## same for "contacted_by", in a group with "contacted_since"
            if item == "contacted_since__contacted_by":
                continue
            if item == "contacted_by__contacted_since":
                continue
            ## ditto
            if item == 'more_actions__since':
                continue

            possible_values = query_params.getlist(
                "%s_%s" % (include_group[0], item))
            if len(possible_values) == 0:
                continue
            query_data = QUERIES[item]
            extra_data = {}

            istogglename = '%s_%s_istoggle' % (include_group[0], item)
            istoggle = query_params.get(istogglename, '1')
            try:
                istoggle = bool(int(istoggle))
            except ValueError:
                istoggle = True
            extra_data['istoggle'] = istoggle

            ## XXX special cased zip code and distance
            # these two fields are together, if we have another case like this
            # we should probably formalize this
            if item == "zipcode":
                distance = query_params.get('%s_zipcode__distance' % include_group[0])
                if distance:
                    extra_data['distance'] = distance

            ## XXX special cased contacted_since and contacted_by
            # these two fields are together, if we have another case like this
            # we should probably formalize this
            if item == "contacted_since":
                contacted_by = query_params.get(
                    '%s_contacted_since__contacted_by' % include_group[0])
                if contacted_by:
                    extra_data['contacted_by'] = contacted_by

            if item == "contacted_by":
                contacted_since = query_params.get(
                    '%s_contacted_by__contacted_since' % include_group[0])
                if contacted_since:
                    extra_data['contacted_since'] = contacted_since

            if item == "emails_opened":
                since = query_params.get('%s_emails_opened__since' % include_group[0])
                if since:
                    extra_data['since'] = since
            if item == "more_actions":
                since = query_params.get('%s_more_actions__since' % include_group[0])
                if since:
                    extra_data['since'] = since
            if item == "donated_more":
                since = query_params.get('%s_donated_more__since' % include_group[0])
                if since:
                    extra_data['since'] = since
            if item == "donated_times":
                since = query_params.get('%s_donated_times__since' % include_group[0])
                if since:
                    extra_data['since'] = since

            make_query_fn = query_data.get('query_fn', make_default_user_query)
            users, __human_query = make_query_fn(
                users, query_data, possible_values, item, extra_data)
            _human_query.append(__human_query)

        if not _human_query or (
            users.query.sql_with_params() == base_user_query.query.sql_with_params()):
            continue

        all_user_queries.append(users)
        human_query.append("(%s)" % " and ".join(_human_query))

    human_query = "\n or ".join(human_query)
    users = None
    for i, query in enumerate(all_user_queries):
        if i == 0:
            users = query
        else:
            users = users | query
    if users is None:
        users = base_user_query

    ### If both of user_name and user_email are filled out,
    ### search for anyone who matches EITHER condition, rather than both.
    extra_where = []
    extra_params = []
    if query_params.get("user_name"):
        extra_where.append(
            "CONCAT(`core_user`.`first_name`, ' ', `core_user`.`last_name`) LIKE %s")
        extra_params.append("%" + "%".join(query_params['user_name'].split()) + "%")
        human_query += "\n and name is like \"%s\"" % query_params['user_name']
    if query_params.get("user_email"):
        extra_where.append("`core_user`.`email` LIKE %s")
        extra_params.append("%" + query_params.get("user_email") + "%")
        human_query += "\n and email is like \"%s\"" % query_params['user_email']
    if len(extra_where):
        if len(extra_where) == 2:
            extra_where = ["(%s OR %s)" % tuple(extra_where)]
        users = users.extra(
            where=extra_where,
            params=extra_params)

    users = users.extra(select={'phone': (
                "SELECT `normalized_phone` FROM `core_phone` "
                "WHERE `core_phone`.`user_id`=`core_user`.`id` "
                "LIMIT 1"),
                                'campus': (
                "SELECT `value` from `core_userfield` "
                "WHERE`core_userfield`.`parent_id`=`core_user`.`id` "
                'AND `core_userfield`.`name`="campus" LIMIT 1'),
                                'name': (
                "CONCAT(CONCAT(first_name, \" \"), last_name)"),
                                'skills': (
                "SELECT `value` from `core_userfield` "
                "WHERE`core_userfield`.`parent_id`=`core_user`.`id` "
                'AND `core_userfield`.`name`="skills" LIMIT 1'),
                                'engagement_level': (
                "SELECT `value` from `core_userfield` "
                "WHERE`core_userfield`.`parent_id`=`core_user`.`id` "
                'AND `core_userfield`.`name`="engagement_level" LIMIT 1'),
                                'affiliation': (
                "SELECT `value` from `core_userfield` "
                "WHERE`core_userfield`.`parent_id`=`core_user`.`id` "
                'AND `core_userfield`.`name`="affiliation" LIMIT 1'),
                                })
    if users.query.sql_with_params() == base_user_query.query.sql_with_params():
        users = base_user_query.none()

    if queryset_modifier_fn is not None:
        users = queryset_modifier_fn(users)

    if not query_params.get('subscription_all_users', False):
        users = users.filter(subscription_status='subscribed')
        human_query += "\n and subscription_status is 'subscribed'"

    users = users.distinct()
    raw_sql = sql.raw_sql_from_queryset(users)

    del users

    return Query(human_query, querystring, raw_sql, None)
Beispiel #41
0
      order = Order.objects.create(
        order_total=params['mc_gross'],
        order_subtotal=params['mc_gross'],
        user=enrollment.user,
      )
      order.created=enrollment.datetime
      order.updated=enrollment.datetime
      order.status = order.PAID
      order.save()
      order_payments = [OrderPayment.objects.create(
        order=order,
        transaction_id=txn_id,
        backend='paypal',
        description='backfilled paypal payment',
      )]
      for s in [s for s in params.keys() if s.startswith("item_name")]:
        session = enrollment.session
        sessionproduct = session.sessionproduct
        number = s[-1]
        total = params['mc_gross_'+s[-1]]
        order_item = order.items.create(
          product_reference=sessionproduct.pk,
          product_name=params[s],
          product=sessionproduct,
          unit_price=Decimal(total)/enrollment.quantity,
          quantity=enrollment.quantity,
          line_subtotal=total,
          line_total=total
        )
        print "Order created: ",order,'  ',order.created
Beispiel #42
0
def get_del_addref_node(request, **kwargs):
    """ A RESTful api that user can get/delete and make a copy using different method

    Following are the mapping between method and operation:
        1. GET: return all infomation of the node asked.
        2. DELETE: delete the specific node if the logged-in user has access to do so.
        3. PUT: make a copy(actually a ref) that belongs to the project which the user is working on.
        4. PATCH: merely modify the x, y coordinates of specific node

    @param kwargs: kwarg['id'] is the object_id or ref_id
    @param request: django request object
    @type request: django.http.request
    @return: success prompt or error information
    """
    if request.method == 'DELETE':
        '''
            DELETE A REF IN COLLECTION<node_ref>
        '''

        noderef = db.node_ref.find_one({'_id': ObjectId(kwargs['id'])})

        # not found
        if noderef is None:
            return HttpResponse(
                "{'status':'error', 'reason':'no record match that id'}")

        # remove ref in specific node record
        db.node.update({'_id': noderef['node_id']},
                       {'$pull', {"node_refs", noderef['_id']}})

        # remove node_ref record
        db.node_ref.remove({'_id': noderef['_id']})

        return HttpResponse("{'status': 'success'}")

    elif request.method == 'PUT':
        '''
            add a ref record in collection <node_ref>
        '''
        paras = QueryDict(request.body)
        try:
            node = db.node.find_one({'_id': ObjectId(kwargs['id'])})
        except KeyError:
            return HttpResponse(
                "{'status':'error', 'reason':'key <_id> does not exist'}")

        # not found
        if node is None:
            return HttpResponse(
                "{'status':'error', 'reason':'object not found'}")

        # node exists
        noderef_id = db.node_ref.insert({
            'pid':
            int(paras['pid']) if 'pid' in paras.keys() else 0,
            'x':
            paras['x'] if 'x' in paras.keys() else '0',
            'y':
            paras['y'] if 'y' in paras.keys() else '0',
            'node_id':
            node['_id']
        })

        if noderef_id:
            prj_id = db.project.find_one(
                {'pid': int(QueryDict(request.body)['pid'])})
            if prj_id is None:
                prj_id = db.project.insert({
                    'pid':
                    int(QueryDict(request.body)['pid']),
                    'node': [],
                    'link': [],
                })
                prj_id = db.project.find_one({'_id': prj_id})
            else:
                pass
            db.project.update({'_id': prj_id['_id']},
                              {'$push': {
                                  'node': noderef_id
                              }}, True)

            data = {'status': 'success', 'ref_id': str(noderef_id)}
            return HttpResponse(json.dumps(data))
        else:
            return HttpResponse(
                "{'status':'error', 'reason':'fail to insert data into database'}"
            )

    elif request.method == 'GET':
        '''
        get the detail info of a record
        :param kwargs: kwargs['_id'] is the object id in collection node
        '''
        BANNED_ATTRI = {
            '_id': 0,
            'REF': 0,
            'REF_COUNT': 0,
            'ID': 0,
            'FATHER': 0,
            'CHILD': 0
        }
        try:
            node = db.node.find_one({'_id': ObjectId(kwargs['id'])},
                                    BANNED_ATTRI)
        except KeyError:
            return HttpResponse(
                "{'status':'error', 'reason':'key <_id> does not exist'}")

        if node is None:
            # not found
            return HttpResponse(
                "{'status':'error', 'reason':'object not found'}")

        else:
            # the node exists
            node_dic = node
            for key in node_dic.keys():
                if isinstance(node_dic[key], bson.objectid.ObjectId):
                    node_dic[key] = str(node_dic[key])
                if (isinstance(node_dic[key], list) and len(node_dic[key]) > 0
                        and isinstance(node_dic[key][0], ObjectId)):
                    newrefs = []
                    for refid in node_dic[key]:
                        newrefs.append(str(refid))
                    node_dic[key] = newrefs

            return HttpResponse(json.dumps(node_dic))

    elif request.method == 'PATCH':
        '''
        update merely the position(x,y) of the node
        :param request.PATCH: a dict with keys(token, username, info), info is also a dict with keys(x, y, ref_id)
        :return data: {'status': 'success'} if everything goes right
        '''
        paras = QueryDict(request.body)
        try:
            x = paras['x']
            y = paras['y']
            old_ref_id = kwargs['id']
        except KeyError:
            return HttpResponse(
                "{'status': 'error','reason':'your info should include keys: x, y, ref_id'}"
            )

        # x,y should be able to convert to a float number
        try:
            fx = float(x)
            fy = float(y)
        except ValueError:
            return HttpResponse(
                "{'status': 'error','reason':'the x, y value should be float'}"
            )

        node = db.node_ref.find_one({'_id': ObjectId(old_ref_id)})
        if not node:
            return HttpResponse(
                "{'status': 'error','reason':'unable to find the record matching ref_id given'}"
            )
        else:
            db.node_ref.update({'_id': ObjectId(old_ref_id)},
                               {'$set', {
                                   'x': x,
                                   'y': y
                               }})
            return HttpResponse("{'status': 'success}")

    else:
        # method incorrect
        return HttpResponse(
            "{'status': 'error','reason':'pls use method DELETE/PUT/GET/PATCH '}"
        )
Beispiel #43
0
def get_del_addref_link(request, **kwargs):
    """ A RESTful api that user can get/delete and make a copy using different method

    Following are the mapping between method and operation:
        1. GET: return all infomation of the link asked.
        2. DELETE: delete the specific node if the logged-in user has access to do so.
        3. PUT: make a copy(actually a ref) that belongs to the project which the user is working on.
        4. PATCH: merely modify the x, y coordinates of specific node

    @param kwargs: kwarg['id'] is the object_id or ref_id
    @param request: django request object
    @type request: django.http.request
    @return: success prompt or error information
    """
    if request.method == 'DELETE':
        '''
            DELETE A REF IN COLLECTION<link_ref>
        '''

        linkref = db.link_ref.find_one({'_id': ObjectId(kwargs['id'])})

        # not found
        if linkref is None:
            return HttpResponse(
                "{'status':'error', 'reason':'no record match that id'}")

        # remove ref in specific node record
        db.link.update({'_id': linkref['link_id']},
                       {'$pull', {"link_refs", linkref['_id']}})

        # remove node_ref record
        db.link_ref.remove({'_id': linkref['_id']})

        return HttpResponse("{'status': 'success'}")

    elif request.method == 'PUT':
        '''
            add a ref record in collection <node_ref>
        '''
        paras = QueryDict(request.body)
        try:
            link = db.link.find_one({'_id': ObjectId(kwargs['id'])})
        except KeyError:
            return HttpResponse(
                "{'status':'error', 'reason':'key <_id> does not exist'}")

        # not found
        if link is None:
            return HttpResponse(
                "{'status':'error', 'reason':'object not found'}")

        # link exists
        linkref_id = db.link_ref.insert({
            'pid':
            int(paras['pid']) if 'pid' in paras.keys() else 0,
            'link_id':
            paras['_id'],
            'id1':
            ObjectId(paras['id1']),
            'id2':
            ObjectId(paras['id2'])
        })
        if linkref_id:
            prj_id = db.project.find_one(
                {'pid': int(QueryDict(request.body)['pid'])})
            if prj_id is None:
                prj_id = db.project.insert({
                    'pid':
                    int(QueryDict(request.body)['pid']),
                    'node': [],
                    'link': []
                })
                prj_id = db.project.find_one({'_id': prj_id})
            else:
                pass
            db.project.update({'_id': prj_id['_id']},
                              {'$push': {
                                  'link': linkref_id
                              }}, True)

            data = {'status': 'success', 'ref_id': str(linkref_id)}
            return HttpResponse(json.dumps(data))
        else:
            return HttpResponse("{'status':'error', 'reason':'insert failed'}")

    elif request.method == 'GET':
        '''
        get the detail info of a record
        '''
        try:
            link = db.link.find_one({'_id': ObjectId(kwargs['id'])})
        except KeyError:
            return HttpResponse(
                "{'status':'error', 'reason':'key <_id> does not exist'}")

        if link is None:
            # not found
            return HttpResponse(
                "{'status':'error', 'reason':'object not found'}")

        else:
            # the node exists
            link_dic = link
            for key in link_dic.keys():
                if isinstance(link_dic[key], bson.objectid.ObjectId):
                    link_dic[key] = str(link_dic[key])
                if (isinstance(link_dic[key], list) and len(link_dic[key]) > 0
                        and isinstance(link_dic[key][0], ObjectId)):
                    newrefs = []
                    for refid in link_dic[key]:
                        newrefs.append(str(refid))
                    link_dic[key] = newrefs

            return HttpResponse(json.dumps(link_dic))

    else:
        # method incorrect
        return HttpResponse(
            "{'status': 'error','reason':'pls use method DELETE/PUT '}")
Beispiel #44
0
                order_total=params['mc_gross'],
                order_subtotal=params['mc_gross'],
                user=enrollment.user,
            )
            order.created = enrollment.datetime
            order.updated = enrollment.datetime
            order.status = order.PAID
            order.save()
            order_payments = [
                OrderPayment.objects.create(
                    order=order,
                    transaction_id=txn_id,
                    backend='paypal',
                    description='backfilled paypal payment',
                )
            ]
            for s in [s for s in params.keys() if s.startswith("item_name")]:
                session = enrollment.session
                sessionproduct = session.sessionproduct
                number = s[-1]
                total = params['mc_gross_' + s[-1]]
                order_item = order.items.create(
                    product_reference=sessionproduct.pk,
                    product_name=params[s],
                    product=sessionproduct,
                    unit_price=Decimal(total) / enrollment.quantity,
                    quantity=enrollment.quantity,
                    line_subtotal=total,
                    line_total=total)
                print "Order created: ", order, '  ', order.created
Beispiel #45
0
def category(request, cat):
	q = QueryDict(cat)
	f = open('cameras', 'r')
	camera_info = pickle.load(f)
	f.close()

	all_zero = True
	if len(q) != 1:
                for category in q:
                        try:
                                weight = int(q[category])
                                if weight != 0:
                                        all_zero = False
                        except:
                                continue
	else:
                all_zero = False
                category_weights = {q.keys()[0]: 1}

	if all_zero:
                return HttpResponseRedirect('/camrec/')

	if len(q) > 1:
                category_weights = {category: float(q[category]) for category in q}

	top_cameras = get_top_cameras(n=15)
	top_cameras = weighted_camera_scores(top_cameras, **category_weights)
	top_camera_prices = []
	for i in range(len(top_cameras)):
		camera_name = top_cameras[i][0]
		if 'price' in camera_info[camera_name]:
			top_camera_prices.append(camera_info[camera_name]['price'])
		else:
			top_camera_prices.append('N/A')
	
        f = open('interface_photos1.dat', 'r')
        interface_photos = pickle.load(f)
        # Convert to {category: {camera: photos, ...}, ...}
        f.close()
        interface_photos = {category: {camera[0]: photos for camera, photos in interface_photos[category].iteritems()} for category in interface_photos}

        categories = filter(lambda c: category_weights[c] > 0, category_weights.keys())
        category_weight_thresholds = []
        weight_threshold = 0.0
        for category in categories:
                weight_threshold += category_weights[category]
                category_weight_thresholds.append(weight_threshold)
        max_weight_threshold = weight_threshold

        photos = defaultdict(list)
        photos_per_camera = 3
        for camera, score in top_cameras[:10]:
                photos[camera] = []
                for i in range(photos_per_camera):
                        rnd_num = random.rand() * max_weight_threshold
                        for j in range(len(category_weight_thresholds)):
                                if rnd_num < category_weight_thresholds[j]:
                                        category = categories[j]
                                        break

                        try:
                                photos_from_camera = interface_photos[category][camera]
                        except KeyError:
                                break

                        if len(photos_from_camera) == 0:
                                continue

                        photo_index = random.randint(0, len(photos_from_camera))
                        photos[camera].append(photos_from_camera[photo_index])
                        interface_photos[category][camera].remove(photos_from_camera[photo_index])


	cameras = [{'camera': top_cameras[i][0], 'price': '%s' % (top_camera_prices[i]), 'photos':photos[top_cameras[i][0]]} for i in range(len(top_cameras[:10]))]

	category_photo_data = load_category_photo_data()
	day_stats = analyze_photos(category_photo_data, time_of_day = "day", **category_weights)
	day_apertureData, day_apertureTicks = get_aperture_plot_data(day_stats)
	day_exposureData, day_exposureTicks = get_exposure_plot_data(day_stats)
	day_focalLengthData, day_focalLengthTicks = get_focal_length_plot_data(day_stats)

	night_stats = analyze_photos(category_photo_data, time_of_day = "night", **category_weights)
	night_apertureData, night_apertureTicks = get_aperture_plot_data(night_stats)
	night_exposureData, night_exposureTicks = get_exposure_plot_data(night_stats)
	night_focalLengthData, night_focalLengthTicks = get_focal_length_plot_data(night_stats)

	if len(q) > 1:
		cat = ''
		for category in q:
			if float(q[category]) > 0:
				cat = cat + category + ':' + q[category] + ' '
	
	context = {'category':cat, 'camera_list':cameras,
                   'night_apertureData':night_apertureData,
                   'night_apertureTicks':night_apertureTicks,
                   'night_focalLengthData':night_focalLengthData,
                   'night_focalLengthTicks': night_focalLengthTicks,
                   'night_exposureData': night_exposureData,
                   'night_exposureTicks': night_exposureTicks,
                   'day_apertureData':day_apertureData,
                   'day_apertureTicks':day_apertureTicks,
                   'day_focalLengthData':day_focalLengthData,
                   'day_focalLengthTicks': day_focalLengthTicks,
                   'day_exposureData': day_exposureData,
                   'day_exposureTicks': day_exposureTicks}

	return render(request, 'camrec/category.html', context)
Beispiel #46
0
    def parse_search_request(self, request_get, search_type=None):
        """
        Processes a request string, dict or QueryDict as the input/criteria for an OCL search.
        The parsed search inputs are saved in self.search_params. Set search_type if type=...
        not included in request_get and search_type != DEFAULT_SEARCH_TYPE. type=... in
        request_get takes priority over search_type attribute.

        :params request_get: request string, dictionary or QueryDict of search inputs/criteria
        :params search_type: Plural name of search_type (e.g. 'concepts', 'sources')
        :returns: None
        """

        search_params_dict = {}

        # Verbose - all searches return full resource details, so set verbose to true
        search_params_dict['verbose'] = 'true'

        # Get into QueryDict format if not already and make a copy
        if isinstance(request_get, QueryDict):
            params = request_get.copy()
        elif isinstance(request_get, basestring):
            params = QueryDict(request_get, mutable=True)
        elif isinstance(request_get, dict):
            params = QueryDict('', mutable=True)
            params.update(request_get)
        else:
            raise TypeError('Expected QueryDict, dict, or str.' +
                            str(request_get) + ' passed.')

        # Determine the search type - gets the latest occurence of type
        if 'type' in params and params[
                'type'] in OclConstants.RESOURCE_TYPE_INFO:
            self.search_type = params['type']
        elif search_type and search_type in OclConstants.RESOURCE_TYPE_INFO:
            self.search_type = search_type
        else:
            self.search_type = self.DEFAULT_SEARCH_TYPE
        if 'type' in params:
            del params['type']

        # Paging - gets the latest occurence of type
        if 'page' in params:
            try:
                self.current_page = int(params['page'])
            except ValueError:
                self.current_page = 1
            del params['page']
        else:
            self.current_page = 1
        search_params_dict['page'] = self.current_page

        # Limit - gets the latest occurence of type
        if 'limit' in params:
            try:
                self.num_per_page = int(params['limit'])
            except ValueError:
                self.num_per_page = self.DEFAULT_NUM_PER_PAGE
            del params['limit']
        else:
            self.num_per_page = self.DEFAULT_NUM_PER_PAGE
        search_params_dict['limit'] = self.num_per_page

        # Sort - gets the latest occurence of sort
        sort_direction = None
        sort_field = None
        if 'sort' in params:
            self.search_sort = params.get('sort', '')
            sort = self.search_sort.lower()
            del params['sort']
            if 'asc' in sort:
                sort_direction = 'sortAsc'
            elif 'desc' in sort:
                sort_direction = 'sortDesc'
            if 'last update' in sort:
                sort_field = 'last_update'
            elif 'name' in sort:
                sort_field = 'name'
            if sort_direction and sort_field:
                search_params_dict[sort_direction] = sort_field

        # Query text
        if 'q' in params:
            self.search_query = params.get('q')
            del params['q']
            search_params_dict['q'] = self.search_query

        # Apply facets/filters - everything that's left should be a filter/facet
        # NOTE: Quoting and URL encoding parameters before passing on to API
        for search_filter_key in params.keys():
            search_filter_value = map(
                lambda x: '"' + x + '"' if ' ' in x else x,
                params.pop(search_filter_key))
            search_params_dict[search_filter_key] = ','.join(
                search_filter_value)

        self.search_params = search_params_dict
Beispiel #47
0
def build_query(querystring, queryset_modifier_fn=None):
    query_params = QueryDict(querystring)

    base_user_query = CoreUser.objects.using("ak").order_by("id")
    
    includes = []

    include_pattern = re.compile("^include:\d+$")
    for key in query_params.keys():
        if (include_pattern.match(key)
            and query_params[key]
            and (not query_params[key].endswith('_istoggle'))):
            includes.append((key, query_params.getlist(key)))

    human_query = []

    extra_where_clauses = dict((clause.name,clause) for clause in WhereClause.objects.all())

    all_user_queries = []
    for include_group in includes:
        users = base_user_query
        _human_query = []
        for item in include_group[1]:
            ## "distance" is handled in a group with "zipcode", so we ignore it here
            if item == "zipcode__distance":
                continue
            ## same for "contacted_by", in a group with "contacted_since"
            if item == "contacted_since__contacted_by":
                continue
            if item == "contacted_by__contacted_since":
                continue
            ## ditto
            if item == 'more_actions__since':
                continue

            from pprint import pprint
            pprint(query_params)
            possible_values = query_params.getlist(
                "%s_%s" % (include_group[0], item))
            if len(possible_values) == 0:
                continue

            print item, possible_values
            istogglename = '%s_%s_istoggle' % (include_group[0], item)
            istoggle = query_params.get(istogglename, '1')
            try:
                istoggle = bool(int(istoggle))
            except ValueError:
                istoggle = True

            if item in extra_where_clauses:
                users, __human_query = extra_where_clauses[item].load()(
                    users, possible_values, is_not=not istoggle)
                _human_query.append(__human_query)
                continue
            
            query_data = QUERIES[item]
            extra_data = {}

            extra_data['istoggle'] = istoggle

            ## XXX special cased zip code and distance
            # these two fields are together, if we have another case like this
            # we should probably formalize this
            if item == "zipcode":
                distance = query_params.get('%s_zipcode__distance' % include_group[0])
                if distance:
                    extra_data['distance'] = distance

            make_query_fn = query_data.get('query_fn', make_default_user_query)
            users, __human_query = make_query_fn(
                users, query_data, possible_values, item, extra_data)
            _human_query.append(__human_query)

        if not _human_query or (
            users.query.sql_with_params() == base_user_query.query.sql_with_params()):
            continue

        all_user_queries.append(users)
        human_query.append("(%s)" % " and ".join(_human_query))

    human_query = "\n or ".join(human_query)
    users = None
    for i, query in enumerate(all_user_queries):
        if i == 0:
            users = query
        else:
            users = users | query
    if users is None:
        users = base_user_query

    ### If both of user_name and user_email are filled out,
    ### search for anyone who matches EITHER condition, rather than both.
    extra_where = []
    extra_params = []
    if query_params.get("user_name"):
        extra_where.append(
            "CONCAT(`core_user`.`first_name`, ' ', `core_user`.`last_name`) LIKE %s")
        extra_params.append("%" + "%".join(query_params['user_name'].split()) + "%")
        human_query += "\n and name is like \"%s\"" % query_params['user_name']
    if query_params.get("user_email"):
        extra_where.append("`core_user`.`email` LIKE %s")
        extra_params.append("%" + query_params.get("user_email") + "%")
        human_query += "\n and email is like \"%s\"" % query_params['user_email']
    if query_params.get("user_akid"):
        akids = [int(i.strip()) for i in query_params["user_akid"].split(",")]
        for akid in akids:
            extra_where.append("`core_user`.`id` = %s")
            extra_params.append(akid)
        human_query += "\n and AKID is in %s" % akids
    if len(extra_where):
        if len(extra_where) == 2:
            extra_where = ["(%s OR %s)" % tuple(extra_where)]
        users = users.extra(
            where=extra_where,
            params=extra_params)

    users = users.extra(select={'phone': (
                "SELECT `normalized_phone` FROM `core_phone` "
                "WHERE `core_phone`.`user_id`=`core_user`.`id` "
                "LIMIT 1"),
                                'name': (
                "CONCAT(CONCAT(first_name, \" \"), last_name)"),
                                })

    columns = SelectColumn.objects.filter(name__in=query_params.getlist("column"))
    for column in columns:
        users = column.load()(users)

    if users.query.sql_with_params() == base_user_query.query.sql_with_params():
        users = base_user_query.none()

    if not query_params.get('subscription_all_users', False):
        users = users.filter(subscription_status='subscribed')
        human_query += "\n and subscription_status is 'subscribed'"

    users = users.distinct()
    users = users.defer("password", "rand_id")

    raw_sql = sql.raw_sql_from_queryset(users, queryset_modifier_fn)

    del users

    return Query(human_query, querystring, raw_sql, None)
Beispiel #48
0
    def parse_search_request(self, request_get, search_type=None):
        """
        Processes a request string, dict or QueryDict as the input/criteria for an OCL search.
        The parsed search inputs are saved in self.search_params. Set search_type if type=...
        not included in request_get and search_type != DEFAULT_SEARCH_TYPE. type=... in
        request_get takes priority over search_type attribute.

        :params request_get: request string, dictionary or QueryDict of search inputs/criteria
        :params search_type: Plural name of search_type (e.g. 'concepts', 'sources')
        :returns: None
        """

        search_params_dict = {}

        # Verbose - all searches return full resource details, so set verbose to true
        search_params_dict['verbose'] = 'true'

        # Get into QueryDict format if not already and make a copy
        print 'parsing:', request_get
        if isinstance(request_get, QueryDict):
            params = request_get.copy()
        elif isinstance(request_get, basestring):
            params = QueryDict(request_get, mutable=True)
        elif isinstance(request_get, dict):
            params = QueryDict('', mutable=True)
            params.update(request_get)
        else:
            raise TypeError('Expected QueryDict, dict, or str.' + str(request_get) + ' passed.')

        # Determine the search type - gets the latest occurence of type
        if 'type' in params and params['type'] in OclConstants.RESOURCE_TYPE_INFO:
            self.search_type = params['type']
        elif search_type and search_type in OclConstants.RESOURCE_TYPE_INFO:
            self.search_type = search_type
        else:
            self.search_type = self.DEFAULT_SEARCH_TYPE
        if 'type' in params:
            del params['type']
        print 'search type:', self.search_type

        # Paging - gets the latest occurence of type
        if 'page' in params:
            try:
                self.current_page = int(params['page'])
            except ValueError:
                self.current_page = 1
            del params['page']
        else:
            self.current_page = 1
        search_params_dict['page'] = self.current_page
        print 'page:', self.current_page

        # Limit - gets the latest occurence of type
        if 'limit' in params:
            try:
                self.num_per_page = int(params['limit'])
            except ValueError:
                self.num_per_page = self.DEFAULT_NUM_PER_PAGE
            del params['limit']
        else:
            self.num_per_page = self.DEFAULT_NUM_PER_PAGE
        search_params_dict['limit'] = self.num_per_page
        print 'limit:', self.num_per_page

        # Sort - gets the latest occurence of sort
        sort_direction = None
        sort_field = None
        if 'sort' in params:
            self.search_sort = params.get('sort', '')
            sort = self.search_sort.lower()
            del params['sort']
            if 'asc' in sort:
                sort_direction = 'sortAsc'
            elif 'desc' in sort:
                sort_direction = 'sortDesc'
            if 'last update' in sort:
                sort_field = 'last_update'
            elif 'name' in sort:
                sort_field = 'name'
            if sort_direction and sort_field:
                search_params_dict[sort_direction] = sort_field
        print 'sort:', self.search_sort, sort_direction, ':', sort_field

        # Query text
        if 'q' in params:
            self.search_query = params.get('q')
            del params['q']
            search_params_dict['q'] = self.search_query
        print 'q:', self.search_query

        # Apply facets/filters - everything that's left should be a filter/facet
        # NOTE: Quoting and URL encoding parameters before passing on to API
        for search_filter_key in params.keys():
            search_filter_value = map(lambda x: '"'+x+'"' if ' ' in x else x,
                                      params.pop(search_filter_key))
            search_params_dict[search_filter_key] = ','.join(search_filter_value)
            print 'search filter [%s] = %s' % (search_filter_key,
                                               search_params_dict[search_filter_key])

        self.search_params = search_params_dict
        print 'Searcher %s params: %s' % (self.search_type, search_params_dict)
def get_one(request, *args, **kwargs):
    if request.method == 'GET':
        user = request.user
        prj_id = _get_prj_id_int(kwargs['prj_id'])
        if not prj_id:
            return HttpResponse("{'status':'error', 'reason':'prj_id not found'}")

        if user.is_authenticated():
            try:
                project = Project.objects.get(pk=prj_id)
            except ObjectDoesNotExist:
                return HttpResponse("{'status':'error', 'reason':'cannot find project matching the given id'}")
            if not (user == project.author or user in project.collaborators.all()):
                return HttpResponse("{'status':'error', 'reason':'you dont have the access to the whole profile'}")
            else:
                clean_result = {
                    'author': project.author.username.encode('ascii', 'replace'),
                    'authorid': project.author.pk,
                    'pid': project.id,
                    'prj_name': project.name.encode('ascii', 'replace'),
                    'species': project.species.encode('ascii', 'replace'),
                    'description': project.description.encode('ascii', 'replace'),
                    'collaborators': [{'uid': coll.pk, 'username': coll.username} for coll \
                                      in project.collaborators.all()],
                }
            data_dict = {'status': 'success', 'result': clean_result}
            return HttpResponse(json.dumps(data_dict))

        else:
            return HttpResponse("{'status':'error', 'reason':'you should be logged in'}")
    elif request.method == 'PUT':
        user = request.user
        prj_id = _get_prj_id_int(kwargs['prj_id'])
        query = QueryDict(request.body)
        if not prj_id:
            return HttpResponse("{'status':'error', 'reason':'prj_id not found'}")

        if user.is_authenticated():
            if _is_author(prj_id, user):
                try:
                    project = Project.objects.get(id=prj_id)
                except ObjectDoesNotExist as e:
                    return HttpResponse("{'status':'error', 'reason':'cannot find project with that id'}")

                prj_attrs = ['name', 'description', 'species']
                for key in query.keys():
                    if key not in prj_attrs:
                        return HttpResponse("{'status':'error', 'reason':'field invalid!'}")
                    try:
                        exec ("project.{0} = query['{1}']".format(key, key))
                        project.save()
                    except Exception as e:
                        return HttpResponse("{'status':'error', 'reason':'wrong key provided'}")

                return HttpResponse("{'status':'success', 'prj_id':%d}" % project.pk)

            else:
                return HttpResponse("{'status':'error', 'reason':'No access! Only the author of the project \
                has the right to delete it'}")
        else:
            return HttpResponse("{'status':'error', 'reason':'user not logged in'}")

    elif request.method == 'DELETE':
        user = request.user
        prj_id = _get_prj_id_int(kwargs['prj_id'])
        if not prj_id:
            return HttpResponse("{'status':'error', 'reason':'prj_id not found'}")

        if user.is_authenticated():
            if _is_author(prj_id, user):
                # the user operating is the author of the project, he/she has the power to delete id
                Project.objects.get(id=prj_id).delete()
                return HttpResponse("{'status':'success'}")

            else:
                return HttpResponse("{'status':'error', 'reason':'No access! Only the author of the project \
                has the right to delete it'}")
        else:
            return HttpResponse("{'status':'error', 'reason':'user not logged in'}")

    else:
        return HttpResponse("{'status':'error', 'reason':'method not correct(GET,DELETE or PUT needed)'}")
Beispiel #50
0
def get_one(request, *args, **kwargs):
    if request.method == 'GET':
        user = request.user
        prj_id = _get_prj_id_int(kwargs['prj_id'])
        if not prj_id:
            return HttpResponse(
                "{'status':'error', 'reason':'prj_id not found'}")

        if user.is_authenticated():
            try:
                project = Project.objects.get(pk=prj_id)
            except ObjectDoesNotExist:
                return HttpResponse(
                    "{'status':'error', 'reason':'cannot find project matching the given id'}"
                )
            if not (user == project.author
                    or user in project.collaborators.all()):
                return HttpResponse(
                    "{'status':'error', 'reason':'you dont have the access to the whole profile'}"
                )
            else:
                clean_result = {
                    'author': project.author.username.encode('ascii', 'replace'),
                    'authorid': project.author.pk,
                    'pid': project.id,
                    'prj_name': project.name.encode('ascii', 'replace'),
                    'species': project.species.encode('ascii', 'replace'),
                    'description': project.description.encode('ascii', 'replace'),
                    'collaborators': [{'uid': coll.pk, 'username': coll.username} for coll \
                                      in project.collaborators.all()],
                }
            data_dict = {'status': 'success', 'result': clean_result}
            return HttpResponse(json.dumps(data_dict))

        else:
            return HttpResponse(
                "{'status':'error', 'reason':'you should be logged in'}")
    elif request.method == 'PUT':
        user = request.user
        prj_id = _get_prj_id_int(kwargs['prj_id'])
        query = QueryDict(request.body)
        if not prj_id:
            return HttpResponse(
                "{'status':'error', 'reason':'prj_id not found'}")

        if user.is_authenticated():
            if _is_author(prj_id, user):
                try:
                    project = Project.objects.get(id=prj_id)
                except ObjectDoesNotExist as e:
                    return HttpResponse(
                        "{'status':'error', 'reason':'cannot find project with that id'}"
                    )

                prj_attrs = ['name', 'description', 'species']
                for key in query.keys():
                    if key not in prj_attrs:
                        return HttpResponse(
                            "{'status':'error', 'reason':'field invalid!'}")
                    try:
                        exec("project.{0} = query['{1}']".format(key, key))
                        project.save()
                    except Exception as e:
                        return HttpResponse(
                            "{'status':'error', 'reason':'wrong key provided'}"
                        )

                return HttpResponse("{'status':'success', 'prj_id':%d}" %
                                    project.pk)

            else:
                return HttpResponse(
                    "{'status':'error', 'reason':'No access! Only the author of the project \
                has the right to delete it'}")
        else:
            return HttpResponse(
                "{'status':'error', 'reason':'user not logged in'}")

    elif request.method == 'DELETE':
        user = request.user
        prj_id = _get_prj_id_int(kwargs['prj_id'])
        if not prj_id:
            return HttpResponse(
                "{'status':'error', 'reason':'prj_id not found'}")

        if user.is_authenticated():
            if _is_author(prj_id, user):
                # the user operating is the author of the project, he/she has the power to delete id
                Project.objects.get(id=prj_id).delete()
                return HttpResponse("{'status':'success'}")

            else:
                return HttpResponse(
                    "{'status':'error', 'reason':'No access! Only the author of the project \
                has the right to delete it'}")
        else:
            return HttpResponse(
                "{'status':'error', 'reason':'user not logged in'}")

    else:
        return HttpResponse(
            "{'status':'error', 'reason':'method not correct(GET,DELETE or PUT needed)'}"
        )
def get_one(request, *args, **kwargs):
    if request.method == "GET":
        user = request.user
        prj_id = kwargs["prj_id"]
        if not prj_id:
            return HttpResponse('{"status":"error", "reason":"prj_id not found"}')

        if user.is_authenticated():
            try:
                project = ProjectFile.objects.get(pk=ObjectId(prj_id))
            except ObjectDoesNotExist:
                return HttpResponse('{"status":"error", "reason":"cannot find project matching the given id"}')
            if not (user == project.author or user in project.collaborators):
                return HttpResponse('{"status":"error", "reason":"you dont have the access to the whole profile"}')
            else:
                clean_result = {
                    "author": project.author.username.encode("ascii", "replace"),
                    "authorid": str(project.author.pk),
                    "pid": str(project.pk),
                    "prj_name": project.name.encode("ascii", "replace"),
                    "species": project.species.encode("ascii", "replace"),
                    "description": project.description.encode("ascii", "replace"),
                    "collaborators": [{"uid": str(coll.pk), "username": coll.username} for coll \
                                      in project.collaborators],
                }
            data_dict = {"status": "success", "result": clean_result}
            return HttpResponse(json.dumps(data_dict))

        else:
            return HttpResponse('{"status":"error", "reason":"you should be logged in"}')
    elif request.method == "PUT":
        user = request.user
        prj_id = kwargs["prj_id"]
        query = QueryDict(request.body)
        if not prj_id:
            return HttpResponse('{"status":"error", "reason":"prj_id not found"}')

        if user.is_authenticated():
            if _is_author(prj_id, user):
                try:
                    project = ProjectFile.objects.get(pk=ObjectId(prj_id))
                except ObjectDoesNotExist as e:
                    return HttpResponse('{"status":"error", "reason":"cannot find project with that id"}')

                prj_attrs = ["name", "description", "species"]
                for key in query.keys():
                    if key not in prj_attrs:
                        return HttpResponse('{"status":"error", "reason":"field invalid!"}')
                    try:
                        exec ('project.{0} = query["{1}"]'.format(key, key))
                        project.save()
                    except Exception as e:
                        return HttpResponse('{"status":"error", "reason":"wrong key provided"}')

                return HttpResponse('{"status":"success", "prj_id":%s}' % str(project.pk))

            else:
                return HttpResponse('{"status":"error", "reason":"No access! Only the author of the project \
                has the right to delete it"}')
        else:
            return HttpResponse('{"status":"error", "reason":"user not logged in"}')

    elif request.method == "DELETE":
        user = request.user
        prj_id = kwargs["prj_id"]
        if not prj_id:
            return HttpResponse('{"status":"error", "reason":"prj_id not found"}')

        if user.is_authenticated():
            if _is_author(prj_id, user):
                # the user operating is the author of the project, he/she has the power to delete id
                ProjectFile.objects.get(pk=ObjectId(prj_id)).delete()
                return HttpResponse('{"status":"success"}')

            else:
                return HttpResponse('{"status":"error", "reason":"No access! Only the author of the project \
                has the right to delete it"}')
        else:
            return HttpResponse('{"status":"error", "reason":"user not logged in"}')

    else:
        return HttpResponse('{"status":"error", "reason":"method not correct(GET,DELETE or PUT needed)"}')
Beispiel #52
0
def get_del_addref_node(request, **kwargs):
    """ A RESTful api that user can get/delete and make a copy using different method

    Following are the mapping between method and operation:
        1. GET: return all infomation of the node asked.
        2. DELETE: delete the specific node if the logged-in user has access to do so.
        3. PUT: make a copy(actually a ref) that belongs to the project which the user is working on.
        4. PATCH: merely modify the x, y coordinates of specific node

    @param kwargs: kwarg['id'] is the object_id or ref_id
    @param request: django request object
    @type request: django.http.request
    @return: success prompt or error information
    """
    if request.method == 'DELETE':
        '''
            DELETE A REF IN COLLECTION<node_ref>
        '''

        noderef = db.node_ref.find_one({'_id': ObjectId(kwargs['id'])})

        # not found
        if noderef is None:
            return HttpResponse("{'status':'error', 'reason':'no record match that id'}")

        # remove ref in specific node record
        db.node.update({'_id': noderef['node_id']}, {'$pull', {"node_refs", noderef['_id']}})

        # remove node_ref record
        db.node_ref.remove({'_id': noderef['_id']})

        return HttpResponse("{'status': 'success'}")

    elif request.method == 'PUT':
        '''
            add a ref record in collection <node_ref>
        '''
        paras = QueryDict(request.body)
        try:
            node = db.node.find_one({'_id': ObjectId(kwargs['id'])})
        except KeyError:
            return HttpResponse("{'status':'error', 'reason':'key <_id> does not exist'}")

        # not found
        if node is None:
            return HttpResponse("{'status':'error', 'reason':'object not found'}")

        # node exists
        noderef_id = db.node_ref.insert({'pid': int(paras['pid']) if 'pid' in paras.keys() else 0,
                                         'x': paras['x'] if 'x' in paras.keys() else '0',
                                         'y': paras['y'] if 'y' in paras.keys() else '0',
                                         'node_id': node['_id']}
        )



        if noderef_id:
            prj_id = db.project.find_one({'pid': int(QueryDict(request.body)['pid'])})
            if prj_id is None:
                prj_id = db.project.insert({
                        'pid': int(QueryDict(request.body)['pid']),
                        'node': [],
                        'link': [],
                    }
                )
                prj_id = db.project.find_one({'_id': prj_id})
            else:
                pass
            db.project.update({'_id': prj_id['_id']}, {'$push': {'node': noderef_id}}, True)

            data = {'status': 'success', 'ref_id': str(noderef_id)}
            return HttpResponse(json.dumps(data))
        else:
            return HttpResponse("{'status':'error', 'reason':'fail to insert data into database'}")

    elif request.method == 'GET':
        '''
        get the detail info of a record
        :param kwargs: kwargs['_id'] is the object id in collection node
        '''
        BANNED_ATTRI = {'_id': 0, 'REF': 0, 'REF_COUNT': 0, 'ID': 0, 'FATHER': 0, 'CHILD': 0}
        try:
            node = db.node.find_one({'_id': ObjectId(kwargs['id'])}, BANNED_ATTRI)
        except KeyError:
            return HttpResponse("{'status':'error', 'reason':'key <_id> does not exist'}")

        if node is None:
            # not found
            return HttpResponse("{'status':'error', 'reason':'object not found'}")

        else:
            # the node exists
            node_dic = node
            for key in node_dic.keys():
                if isinstance(node_dic[key], bson.objectid.ObjectId):
                    node_dic[key] = str(node_dic[key])
                if (isinstance(node_dic[key], list) and len(node_dic[key]) > 0 and
                        isinstance(node_dic[key][0], ObjectId)):
                    newrefs = []
                    for refid in node_dic[key]:
                        newrefs.append(str(refid))
                    node_dic[key] = newrefs

            return HttpResponse(json.dumps(node_dic))

    elif request.method == 'PATCH':
        '''
        update merely the position(x,y) of the node
        :param request.PATCH: a dict with keys(token, username, info), info is also a dict with keys(x, y, ref_id)
        :return data: {'status': 'success'} if everything goes right
        '''
        paras = QueryDict(request.body)
        try:
            x = paras['x']
            y = paras['y']
            old_ref_id = kwargs['id']
        except KeyError:
            return HttpResponse("{'status': 'error','reason':'your info should include keys: x, y, ref_id'}")

        # x,y should be able to convert to a float number
        try:
            fx = float(x)
            fy = float(y)
        except ValueError:
            return HttpResponse("{'status': 'error','reason':'the x, y value should be float'}")

        node = db.node_ref.find_one({'_id': ObjectId(old_ref_id)})
        if not node:
            return HttpResponse("{'status': 'error','reason':'unable to find the record matching ref_id given'}")
        else:
            db.node_ref.update({'_id': ObjectId(old_ref_id)}, {'$set', {'x': x, 'y': y}})
            return HttpResponse("{'status': 'success}")

    else:
        # method incorrect
        return HttpResponse("{'status': 'error','reason':'pls use method DELETE/PUT/GET/PATCH '}")
Beispiel #53
0
def track(request, id):
    # Find track
    try:
        track = Track.objects.get(id=id)
    except Track.DoesNotExist:
        raise Http404('Track with ID ' + id + ' does not exist.')

    # Examine request
    if request.method == 'GET':
        return JSONResponse(track, request.GET.get('callback'))

    elif request.method == 'HEAD':
        return HttpResponse()

    elif request.method == 'POST':
        # Conflict, track already exists
        return HttpResponse(status=409)

    elif request.method == 'PUT':
        put = QueryDict(request.body)
        # TODO: Replace ad hoc implementation
        name = put.get('track')
        #album_id = put.get('album_id')
        if not name:
            return HttpResponse(status=400)

        duration = put.get('duration')
        if not duration:
            duration = None
        else:
            try:
                duration = timedelta(seconds=int(duration))
            except ValueError:
                # Unable to convert duration to int
                return HttpResponse(status=400)

        # Assign values
        track.name = name
        track.duration = duration
        track.save()

        return HttpResponse()

    elif request.method == 'PATCH':
        patch = QueryDict(request.body)
        modified = False
        # TODO: Dynamic implementation
        if 'track' in patch.keys():
            track.name = patch.get('track')
            modified = True

        if 'duration' in patch.keys():
            try:
                track.duration = timedelta(seconds=int(patch.get('duration')))
                modified = True
            except ValueError:
                # Unable to convert duration to int
                return HttpResponse(status=400)

        if modified:
            track.save()

        return HttpResponse()

    elif request.method == 'DELETE':
        # Delete track
        track.delete()
        return HttpResponse()

    return HttpResponse(status=405)
Beispiel #54
0
def get_params(request, resource_name):
    """ Extract the parameters passed to an API request.

        We extract the query parameters associated with the given HTTP request,
        optionally stripping the given resource name from the parameter names.

        The parameters are as follows:

            'request'

                The HttpRequest object passed to the view.

            'resource_name'

                The name of the resource to remove from the parameter names, if
                any.

        If 'resource_name' is not None, we look for parameters with a name that
        looks like this:

            resource_name[name]

        For any parameters like this, we remove the resource name from the
        parameter name.  Otherwise, the parameter name will be used directly.

        If 'resource_name' is None, the names of the parameters will not be
        altered.

        Upon completion, we return a QueryDict containing the processed
        request parameters, with the resource name removed if appropriate.

        Note that for uploaded files, the value of the field will be a
        django.core.files.File object representing the uploaded file.
    """
    # Get the raw parameters from the HTTP request.  Note that how we do this
    # depends on the HTTP method and content type.

    if request.method == "GET":
        # "GET" request parameters are already handled by Django.
        raw_params = request.GET
    else:
        # All other methods store their parameters in the body of the request
        # as either url-encoded or multipart-form data.

        content_type,pdict = cgi.parse_header(request.META['CONTENT_TYPE'])

        if content_type == "application/x-www-form-urlencoded":
            raw_params = QueryDict(request.read())
        elif content_type == "multipart/form-data":

            environ = {}
            for key,value in request.META.items():
                if key == "QUERY_STRING": # Fix duplicated query strings.
                    value = ""
                environ[key] = value

            raw_contents = request.read()
            content_file = cStringIO.StringIO(raw_contents)
            parsed_data  = cgi.FieldStorage(content_file, environ=environ)

            raw_params = mutable_QueryDict()
            for key in parsed_data.keys():
                field  = parsed_data[key]
                values = []

                if isinstance(field, list):
                    # We have more than one value with this name.
                    fields = []
                    for f in field:
                        fields.append(f)
                else:
                    fields = [field]

                for field in fields:
                    if field.filename != None:
                        # Handle file uploads specially.
                        field.file.seek(0, 2) # Seek to end of file.
                        file_size = field.file.tell()
                        field.file.seek(0) # Reset to beginning of file.

                        file = File(field.file)
                        file.name = field.filename
                        file.size = file_size
                        values.append(file)
                    else:
                        values.append(field.value)

                raw_params.setlist(key, values)

    # Now parse the raw parameters, stripping off the resource name if
    # required.

    params = mutable_QueryDict()

    for raw_param_name in raw_params.keys():
        if resource_name == None:
            param_name = raw_param_name
        else:
            strip = True # initialy.

            if not raw_param_name.startswith(resource_name + "["):
                strip = False

            if strip and not raw_param_name.endswith("]"):
                strip = False

            if strip:
                s = raw_param_name[len(resource_name)+1:-1]
                if "[" in s:
                    strip = False

            if strip:
                if "]" in s:
                    strip = False

            if strip:
                param_name = s
            else:
                param_name = raw_param_name

        params.setlist(param_name, raw_params.getlist(raw_param_name))

    # Finally, return the processed parameters back to the caller.

    return params