Пример #1
0
    def dispatch(self, *args, **kwargs):
        if self.request.method == "POST":
            data = self.request.POST
        elif self.request.method == "GET":
            data = self.request.GET
        elif self.request.method in ["PATCH", "PUT"]:
            data_dict = yaml.safe_load(self.request.body.decode())
            data = QueryDict(urlencode(data_dict) if data_dict else {})
        else:
            data = QueryDict()

        method = data.get('_method', self.request.method)

        if method:
            if method not in self.allowed:
                return HttpResponseNotAllowed(
                    self.allowed, "Method Not Allowed (" + method + ")")

            if '_method' in data:
                data._mutable = True
                del data['_method']
                data._mutable = False

            self.request.method = method
            self.request.META['REQUEST_METHOD'] = method
            setattr(self.request, method, data)

        return super(HttpMethodMixin, self).dispatch(*args, **kwargs)
Пример #2
0
def index(request):
    select_detailed_source = SelecrSourceForm()
    source_points = Source.objects.exclude(point=None)
    searchform = SearchForm(request.GET)
    tagcloud = Tag.objects.cloud_for_model(Resource)
    qs = Resource.objects.filter(enabled=True).exclude(status="rejected")
    query = request.GET.get("q", None)
    if query != None:
        if query != "":
            qs = qs.filter(search_query_set(query))
        else:
            blankquery = True
        objects = []
        [objects.append(item) for item in qsfiltered]
        # treat querystring, remove page
        querystring = QueryDict(request.META.get("QUERY_STRING"))
        # handle pagination
        if "page" in request.GET:
            pageid = request.GET.get("page")
            if pageid:
                querystring._mutable = True
                del querystring["page"]
            querystring_nopage = querystring.urlencode()
        else:
            pageid = 1
            querystring_nopage = request.META.get("QUERY_STRING")

        paginator = Paginator(objects, CONTENT_PER_PAGE)

        try:
            page_obj = paginator.page(pageid)
        except TypeError:
            page_obj = paginator.page(1)
        except PageNotAnInteger:
            page_obj = paginator.page(1)
        except EmptyPage:
            page_obj = paginator.page(paginator.num_pages)
        object_list = page_obj.object_list
        return render_to_response("index.html", locals(), context_instance=RequestContext(request))

    else:
        # browse mode
        # featured list
        curricular_grades = CurricularGrade.objects.filter(parent=None)
        featured_list = (
            qs.filter(
                # category__code='video', thumbnails__gt=0
            )
            .order_by("?")
            .all()[0:2]
        )
        if featured_list.count() > 0:
            featured_list = featured_list.all()
        # tags
        tags_to_cloud = Tag.objects.usage_for_queryset(qs, counts=True)  # [0:20]
        calculate_cloud(tags_to_cloud, steps=5, distribution=LOGARITHMIC)
        query = ""
        # latest additions
        latest_additions = Resource.objects.filter(status="installed").order_by("-created")[0:5]
        return render_to_response("index.html", locals(), context_instance=RequestContext(request))
Пример #3
0
 def next_urlencode(self):
     # next——新增、编辑后跳转至原页面
     url = self.request.get_full_path()
     qd = QueryDict()
     qd._mutable = True
     qd['next'] = url
     return qd.urlencode()
Пример #4
0
 def get_query_params(self):
     url = self.request.get_full_path()
     qd = QueryDict()
     qd._mutable = True
     qd['next'] = url
     query_params = qd.urlencode()
     return query_params
Пример #5
0
 def get_refurl_context(self, name, value, attrs):
     attrs['data-url'] = resolve_url(self.refurl)
     if self.filters:
         query = QueryDict('', mutable=True)
         for k, v in self.filters.items():
             if isinstance(v, (tuple, list)):
                 v = ','.join(v)
             query.appendlist(k, v)
         query._mutable = False
         attrs['data-filters'] = query.urlencode()
     if isinstance(value, (tuple, list)):
         value = [x for x in value if x]
     context = {}
     context['widget'] = {
         'name': name,
         'is_hidden': self.is_hidden,
         'required': self.is_required,
         'value': self.format_value(value),
         'attrs': self.build_attrs(self.attrs, attrs),
         'template_name': self.template_name,
     }
     if self.allow_multiple_selected:
         context['widget']['attrs']['multiple'] = True
     if value:
         context['value'] = self.get_instance(value)
     return context
Пример #6
0
def get_url(request):
    url = request.get_full_path()
    qd = QueryDict()
    qd._mutable = True
    qd['next_page'] = url
    # query_params = qd.urlencode()

    return qd
Пример #7
0
 def get_query_params(self):
     url = self.request.get_full_path()
     qd = QueryDict()
     qd._mutable = True
     qd['next'] = url
     # next=%2Fcrm%2Fcustomer_list%2F
     query_params = qd.urlencode()
     return query_params
Пример #8
0
 def get_add_btn(self):
     url = self.request.get_full_path()
     qd = QueryDict()
     qd._mutable = True
     qd['next'] = url
     query_params = qd.urlencode()
     add_btn = '<a href="{}?{}" class="btn btn-primary btn-sm">添加</a>'.format(reverse('add_customer'), query_params)
     return mark_safe(add_btn), query_params
Пример #9
0
	def _post(self, request, *args, **kwargs):
		data = request.POST
		if not request.POST:
			simple_dict = json.loads(request.body.decode('utf-8'))
			data = QueryDict('', mutable=True)
			data.update(simple_dict)

		upload_id = data.get('upload_id')
		md5 = {}
		if 'md5' in data:
			for key, value in data.get("md5").items():
				md5[key] = value
		else:
			for key, value in data.dict().items():
				m = re.search('(?P<key>[^[]*)\[(?P<field>.*)\]', key)
				if m and m.group('key') == 'md5':
					md5[m.group('field')] = value

		error_msg = None
		if self.do_md5_check:
			if not upload_id or not md5:
				error_msg = "Both 'upload_id' and 'md5' are required"
		elif not upload_id:
			error_msg = "'upload_id' is required"
		if error_msg:
			raise ChunkedUploadError(status=http_status.HTTP_400_BAD_REQUEST,
									 detail=error_msg)

		for chunked_upload in self.get_queryset(request).filter(dataset__upload_id=upload_id):
			self.validate(request)
			self.is_valid_chunked_upload(chunked_upload)
			if self.do_md5_check:
				self.md5_check(chunked_upload, md5[chunked_upload.field_name])

			chunked_upload.status = COMPLETE
			chunked_upload.completed_on = timezone.now()
			self._save(chunked_upload)
			mutable = data._mutable
			data._mutable = True
			data['file_name'] = chunked_upload.field_name
			data._mutable = mutable
			self.on_completion(chunked_upload.get_uploaded_file(), request)

		return Response(self.get_response_data(upload_id, request),
						status=http_status.HTTP_200_OK)
Пример #10
0
def dict_querydict(dict_):
    """
    Converts a value created by querydict_dict back into a Django QueryDict value.
    """
    q = QueryDict("", mutable=True)
    for k, v in dict_.iteritems():
        q.setlist(k, v)
    q._mutable = False
    return q
Пример #11
0
    def test_add_wildcard_without_exact_match(self):
        query_dict = QueryDict('', mutable=True)
        query_dict.update(**{'q': 'some search phrase', 'exact_match': False})
        query_dict._mutable = False
        request = FakeRequest(query_dict)

        SearchStringFormatter.add_wildcard(request)

        self.assertEquals(request.GET['q'], 'some* search* phrase*')
Пример #12
0
    def test_add_wildcard_without_query_string(self):
        query_dict = QueryDict('', mutable=True)
        query_dict.update(**{'exact_match': False})
        query_dict._mutable = False
        request = FakeRequest(query_dict)

        SearchStringFormatter.add_wildcard(request)

        self.assertTrue('q' not in request.GET)
Пример #13
0
def to_querydict(dict):
    """
    Converts a value created by querydict_dict back into a Django QueryDict value.
    """
    q = QueryDict("", mutable=True)
    for k, v in dict.items():
        q.setlist(k, v)
    q._mutable = False
    return q
Пример #14
0
    def test_add_wildcard_with_empty_query_string(self):
        query_dict = QueryDict('', mutable=True)
        query_dict.update(**{'q': '', 'exact_match': False})
        query_dict._mutable = False
        request = FakeRequest(query_dict)

        SearchStringFormatter.add_wildcard(request)

        self.assertEquals(request.GET['q'], '')
Пример #15
0
 def get_add_url(self):
     url = 'stark:%s_%s_add' % (self.model._meta.app_label,
                                self.model._meta.model_name)
     add_url = reverse(url, )
     # print("edit_url",edit_url)
     q = QueryDict()
     q._mutable = True
     q["_listfilter"] = self.request.GET.urlencode()
     new_edit_url = add_url + "?%s" % q.urlencode()
     return new_edit_url
Пример #16
0
 def get_edit_link_tag(self, obj, val):
     edit_url = self.model_stark_obj.get_edit_url(obj)
     q = QueryDict()
     q._mutable = True
     if not self.request.GET:
         q["_page"] = 1
     else:
         q["_listfilter"] = self.request.GET.urlencode()
     new_edit_url = edit_url + "?%s" % q.urlencode()
     return mark_safe("<a href='" + new_edit_url + "'>" + val + "</a>")
Пример #17
0
 def json_decode(body, encoding=None):
     data = json.loads(body, encoding=encoding)
     query_dict = QueryDict(mutable=True)
     try:
         query_dict.update(data)
     except AttributeError:
         # data is not a mapping (hasn't items() method)
         raise ValueError
     query_dict._mutable = False
     return query_dict
Пример #18
0
def build_querydict(data):
    qd = QueryDict('', mutable=True)
    for key, value in data.items():
        if isinstance(value, list):
            for v in value:
                qd.update({key: v})
        else:
            qd.update({key: value})
    qd._mutable = False
    return qd
Пример #19
0
 def get_query_params(self):
     """
      获取query_params,相当于url后面的拼接参数
     """
     qd = QueryDict()
     qd._mutable = True
     url = self.request.get_full_path()
     qd['next'] = url
     query_params = qd.urlencode()
     return query_params
Пример #20
0
    def get_query_params(self):
        url = self.request.get_full_path()
        # 新建QueryDict()对象
        qd = QueryDict()
        # 添加修改权限
        qd._mutable = True
        # 增加一堆键值对
        qd['next'] = url

        query_params = qd.urlencode()
        return query_params
Пример #21
0
    def get_next(self):
        # 获取当前页面的全路径, 包含get参数, 如: /crm/customer_list/?query=user&page=2
        next_url = self.request.get_full_path()

        # 创建QueryDict字典
        qDict = QueryDict()
        # 将这个字典设为可修改
        qDict._mutable = True
        qDict['next'] = next_url

        return qDict
Пример #22
0
    def get_add_btn(self):
        # 获取添加按钮
        url = self.request.get_full_path()

        qd = QueryDict()
        qd._mutable = True
        qd['next'] = url
        query_params = qd.urlencode()
        add_btn = '<a href="{}?{}" class="btn btn-primary btn-sm" style="margin-bottom: 10px">添加</a>'.format(
            reverse('crm:add_customer', args=(0, )), query_params)
        return mark_safe(add_btn), query_params
Пример #23
0
 def get_add_btn(self):
     """
      获取add按钮
     """
     qd = QueryDict()
     qd._mutable = True
     url = self.request.get_full_path()
     qd['next'] = url
     query_params = qd.urlencode()
     add_btn = '<a href="{}?{}" class="btn btn-info" style="margin: 11px 0">添加客户</a>'.format(
         reverse('crm:add_customer'), query_params)
     return add_btn, query_params
Пример #24
0
def dict_to_querydict(dict_):
    """
    Converts a dict value into the Django's QueryDict object.
    """
    query_dict = QueryDict('', mutable=True)
    for name, value in dict_.items():
        if isinstance(name, list):
            query_dict.setlist(name, value)
        else:
            query_dict.appendlist(name, value)
    query_dict._mutable = False
    return query_dict
Пример #25
0
    def parse(query_params, request):
        if get_style(request) == 'camelcase':
            q = QueryDict('', mutable=True, encoding=query_params.encoding)
            for k, l in query_params.lists():
                q.setlist(
                    to_snake_case(k), k != ORDERING_PARAM and l
                    or list(map(to_snake_case, l)))
            q._mutable = False
            return q

        else:
            return query_params
Пример #26
0
 def cleaned_data_querydict(self):
     """
     Creates an immutable QueryDict instance from the form's cleaned_data
     """
     query = QueryDict("", mutable=True)
     # make sure cleaned_data is available, if possible ...
     self.is_valid()
     cleaned_data = getattr(self, "cleaned_data", {})
     for key, values in cleaned_data.items():
         query.setlist(key=key, list_=values)
     query._mutable = False
     return query
Пример #27
0
 def cleaned_data_querydict(self):
     """
     Creates an immutable QueryDict instance from the form's cleaned_data
     """
     query = QueryDict('', mutable=True)
     # make sure cleaned_data is available, if possible ...
     self.is_valid()
     cleaned_data = getattr(self, 'cleaned_data', {})
     for key, values in cleaned_data.items():
         query.setlist(key=key, list_=values)
     query._mutable = False
     return query
Пример #28
0
    def json_decode(body, encoding=None):
        data = json.loads(body, encoding=encoding)

        query_dict = QueryDict(mutable=True)

        try:
            query_dict.update(data)
        except AttributeError:
            raise ValueError

        query_dict._mutable = False

        return query_dict
Пример #29
0
 def modify(self, obj=None, is_head=False):
     if obj:
         edit_url = self.get_edit_url(obj)
         q = QueryDict()
         q._mutable = True
         if not self.request.GET:
             q[self.page_key] = 1
         else:
             q["_listfilter"] = self.request.GET.urlencode()
         new_edit_url = edit_url + "?%s" % q.urlencode()
         return mark_safe("<a href='" + new_edit_url + "'>编辑</a>")
     if is_head:
         return "操作"
Пример #30
0
 def get_add_btn(self):
     url = self.request.get_full_path()
     # 新建QueryDict()对象
     qd = QueryDict()
     # 添加修改权限
     qd._mutable = True
     # 增加一堆键值对
     qd['next'] = url
     # 将QueryDict对象转化成a=b的形式
     query_params = qd.urlencode()
     # 生成一个新建标签,并拼接url
     add_btn = '<a class="btn btn-primary" href="{}?{} ">增加</a>'.format(
         reverse('add_customer'), query_params)
     return add_btn, query_params
Пример #31
0
 def params_to_snake_case(request: HttpRequest, method: str):
     """
     Convert GET or POST params to snake_case
     :param request:
     :param method:
     :return:
     """
     request_method = getattr(request, method)
     request_method._mutable = True
     request_params_dict = nested_snake_case_transformer(request_method.dict())
     request_params = QueryDict('', mutable=True)
     request_params.update(request_params_dict)
     request_params._mutable = False
     setattr(request, method, request_params)
Пример #32
0
    def get_add_btn(self):
        # 获取添加按钮

        url = self.request.get_full_path()

        qd = QueryDict()
        qd._mutable = True
        qd['next'] = url
        # next=%2Fcrm%2Fcustomer_list%2F%3Fquery%3Dalex%26page%3D2
        query_params = qd.urlencode()

        # add_btn = '<a href="{}?next={}" class="btn btn-primary btn-sm">添加</a>'.format(reverse('add_customer'), url)
        add_btn = '<a href="{}?{}" class="btn btn-primary btn-sm">添加</a>'.format(reverse('add_customer'), query_params)

        return mark_safe(add_btn), query_params
Пример #33
0
 def get_add_btn(self):
     # 获取添加按钮
     url = self.request.get_full_path()
     qd = QueryDict()
     qd._mutable = True
     qd['next'] = url
     print(qd)
     query_params = qd.urlencode()
     print('query_params', query_params)
     # add_btn = '<a href="{}?next={}" class="btn btn-primary btn-sm" style="margin-bottom: 10px">添加</a>'.format(
     #     reverse('crm:add_customer'), url)
     # 这是一种给templates加next 的方法,编辑那也是一种直接将next={{ query_params }}
     add_btn1 = '<a href="{}?{}" class="btn btn-primary btn-sm" style="margin-bottom: 10px">添加</a>'.format(
         reverse('crm:add_customer'), query_params)
     # print(add_btn)
     print(add_btn1)
     return mark_safe(add_btn1), query_params
Пример #34
0
 def modify(self, obj=None, is_head=False):
     if obj:
         edit_url = self.get_edit_url(obj)
         # current_page = self.get_page_obj(request).current_page
         # edit_url=edit_url+"?page=%s"%current_page
         # edit_url=request.get_full_path()
         q = QueryDict()
         q._mutable = True
         if not self.request.GET:
             q["_page"] = 1
         else:
             q["_listfilter"] = self.request.GET.urlencode()
         new_edit_url = edit_url + "?%s" % q.urlencode()
         # print(new_edit_url)
         return mark_safe("<a href='" + new_edit_url + "'>编辑</a>")
     if is_head:
         return "操作"
Пример #35
0
def set_profile(request):
    post_data = request.POST.copy()
    profile = get_profile(request)
    # print('profile admin', profile.sex)
    # print('post_data', post_data)
    new_dict = dict(post_data.iterlists())
    # print('new_dict', new_dict)
    new_dict[u"sex"] = [unicode(profile.sex)]
    # print('new_dict_sex', new_dict)
    #  convertir el dict {} python en un QueryDict
    post_data = QueryDict("", mutable=True)
    for k, v in new_dict.iteritems():
        post_data.setlist(k, v)
    post_data._mutable = False
    print('post_data2', post_data)
    profile_form = UserProfileForm(None, post_data, instance=profile)
    if profile_form.is_valid():
        print('tamos entrando')
        # print(profile_form.se)
        profile_form.save()
    else:
        print('errors', profile_form.errors)
Пример #36
0
def test_accounts_login(client, request_users, settings):
    user = request_users["user"]
    if user.username == "nobody":
        return

    settings.POOTLE_CAPTCHA_ENABLED = False
    password = request_users["password"]
    qdict = QueryDict(mutable=True)
    qdict.update(
        {'login': user.username,
         'password': password})
    qdict._mutable = False
    response = client.post(
        '/accounts/login/',
        qdict,
        HTTP_X_REQUESTED_WITH='XMLHttpRequest')
    email = EmailAddress.objects.filter(user=user, primary=True).first()
    assert response.request['PATH_INFO'] == '/accounts/login/'
    assert response.status_code == 200
    if email is not None and email.verified:
        assert response.json() == {u"location": "/"}
    else:
        assert response.json() == {u"location": "/accounts/confirm-email/"}
Пример #37
0
def test_submit_with_suggestion_and_comment(client, request_users,
                                            settings, system):
    """Tests translation can be applied after suggestion is accepted."""
    settings.POOTLE_CAPTCHA_ENABLED = False
    Comment = get_comment_model()
    unit = Unit.objects.filter(
        suggestion__state__name='pending',
        state=UNTRANSLATED)[0]
    last_sub_pk = unit.submission_set.order_by(
        "id").values_list("id", flat=True).last() or 0
    sugg = Suggestion.objects.filter(unit=unit, state__name='pending')[0]
    user = request_users["user"]

    if user.username != "nobody":
        client.login(
            username=user.username,
            password=request_users["password"])

    url = '/xhr/units/%d/' % unit.id
    edited_target = "Edited %s" % sugg.target_f
    comment = 'This is a comment!'
    qdict = QueryDict(mutable=True)
    qdict.update(
        {'state': False,
         'target_f_0': edited_target,
         'suggestion': sugg.id,
         'comment': comment})
    qdict._mutable = False
    response = client.post(
        url,
        qdict,
        HTTP_X_REQUESTED_WITH='XMLHttpRequest')
    suggestion = Suggestion.objects.get(id=sugg.id)
    unit = Unit.objects.get(id=unit.id)
    new_subs = unit.submission_set.filter(id__gt=last_sub_pk).order_by("id")
    if check_permission('translate', response.wsgi_request):
        assert response.status_code == 200
        content = json.loads(response.content)
        assert content['newtargets'] == [edited_target]
        assert content['user_score'] == response.wsgi_request.user.public_score
        assert content['checks'] is None
        unit_source = unit.unit_source.get()
        assert unit_source.created_by == system
        assert unit_source.created_with == SubmissionTypes.SYSTEM
        assert unit.change.submitted_by == suggestion.user
        assert unit.change.reviewed_by == user
        assert unit.change.changed_with == SubmissionTypes.WEB

        assert suggestion.state.name == 'accepted'
        assert str(unit.target) == edited_target
        assert (Comment.objects
                       .for_model(suggestion)
                       .get().comment == comment)
        assert new_subs.count() == 2
        target_sub = new_subs[0]
        assert target_sub.old_value == ""
        assert target_sub.new_value == unit.target
        assert target_sub.field == SubmissionFields.TARGET
        assert target_sub.type == SubmissionTypes.WEB
        assert target_sub.submitter == unit.change.submitted_by
        assert target_sub.suggestion == suggestion
        assert target_sub.revision == unit.revision
        assert target_sub.creation_time == unit.change.reviewed_on

        state_sub = new_subs[1]
        assert state_sub.old_value == str(UNTRANSLATED)
        assert state_sub.new_value == str(unit.state)
        assert state_sub.suggestion == suggestion

        assert state_sub.field == SubmissionFields.STATE
        assert state_sub.type == SubmissionTypes.WEB

        assert state_sub.submitter == unit.change.submitted_by
        assert state_sub.revision == unit.revision
        assert state_sub.creation_time == unit.change.reviewed_on
    else:
        assert response.status_code == 403
        assert suggestion.state.name == "pending"
        assert unit.target == ""
        assert new_subs.count() == 0
        with pytest.raises(UnitChange.DoesNotExist):
            unit.change