Beispiel #1
0
 def post(self, request, *args, **kwargs):
     # 接收前端数据
     rqs = QueryDict(request.body).dict()
     rqsbooks = rqs['books']
     print rqsbooks
     books = [book.strip() for book in json.loads(rqsbooks)]
     # 判断书在不在数据库,在单独话存数据,不在返回错误信息
     errorinfo = []
     bookobjs = []
     for book in books:
         try:
             bookobj = self.bookmodel.objects.get(name=book)
         except self.bookmodel.DoesNotExist:
             errorinfo.append({'name': book})
         else:
             bookobjs.append(bookobj)
     if errorinfo:
         return JsonResponse({'status': -1, 'data': errorinfo})
     # 创建作者对象(即除了书以外的)
     rqs.pop('books')
     authorobj = self.model.objects.create(**rqs)
     # 写作者和书的manytomany关系
     for bookobj in bookobjs:
         bookobj.author.add(authorobj)
     return JsonResponse({'status': 0})
Beispiel #2
0
def upload_recv(request):
    print("enter upload recev")
    # print(request.body)
    data = QueryDict(request.body).copy()
    print(data)
    print(profile_temp == None)
    gender = int(profile_temp['gender'][0])
    age = int(profile_temp['age'][0])
    language = profile_temp['language']
    active = int(profile_temp['active'][0])
    region = profile_temp['region']
    p = Profile(gender, age, language, active, region)

    location_list = data.pop('location')
    season_list = data.pop('season')
    budget_list = data.pop('budget')
    duration_list = data.pop('duration')
    style_list = data.pop('style')
    itinerary_length = len(location_list)
    print(location_list)
    it = Itinerary('Home')
    for i in range(itinerary_length):
        trip_node = TripNode(location_list[i], int(season_list[i]),
                             int(budget_list[i]), int(budget_list[i]),
                             int(style_list[i]))
        it.add(trip_node)

    db.add_to_table(p, it)
    ans = "Thank you for your sharing! We have uploaded your itinerary to our database. Feel free to visit others' itinerary for your next trip."
    return render(request, 'upload-result.html', {'upload_recv': ans})
 def process_request(self, request):
     if "_pjax" in request.META.get("QUERY_STRING", ""):
         qs = QueryDict(request.META.get("QUERY_STRING", ""),
                        encoding=request.encoding, mutable=True)
         qs.pop("_pjax", None)
         request.META["QUERY_STRING"] = qs.urlencode()
         request.META["PJAX"] = True
Beispiel #4
0
    def put(self, request, *args, **kwargs):
        pk = kwargs.get('pk')
        try:
            nc = NetworkCable.objects.get(id=pk)
            put_data = QueryDict(request.body, mutable=True)
            idc_id = put_data.pop('idc_id')[0]
            count = put_data.pop('count')[0]
            acc_list = Accessory.objects.filter(storehouse__id=idc_id,
                                                mode='network_cable',
                                                mode_id=nc.id,
                                                is_active=True)
            if acc_list.count() < int(count):
                res = {"code": 1, "errmsg": "可用数量不足!"}
                return JsonResponse(res, safe=True)
            for a in acc_list[:int(count)]:
                a.is_active = False
                a.save(update_fields=['is_active'])
            InventoryRecord.objects.create(
                accessory='network_cable',
                operate='receive',
                content='%s %d米 网线 %s 根!' %
                (nc.get_cat_display(), nc.length, count),
                user=request.user)

            res = {"code": 0, "result": "领用成功"}
        except Exception as e:
            res = {"code": 1, "errmsg": "领用错误:%s" % str(e)}
        return JsonResponse(res, safe=True)
 def process_request(self, request):
     if "_pjax" in request.META.get("QUERY_STRING", ""):
         qs = QueryDict(request.META.get("QUERY_STRING", ""),
                        encoding=request.encoding,
                        mutable=True)
         qs.pop("_pjax", None)
         request.META["QUERY_STRING"] = smart_str(qs.urlencode())
Beispiel #6
0
    def put(self, request, *args, **kwargs):
        try:
            pk = kwargs.get('pk')
            put_data = QueryDict(request.body, mutable=True)
            white_cmds = put_data.pop('white_cmd') if "white_cmd" in put_data else list()
            perilous_cmds = put_data.pop('perilous_cmd') if "perilous_cmd" in put_data else list()
            sensitive_cmds = put_data.pop('sensitive_cmd') if "sensitive_cmd" in put_data else list()
            if put_data["group_type"] == "white":
                cd_ids = list()
                for pc_id in white_cmds:
                    pc = PerilousCommand.objects.get(id=pc_id)
                    cd = CommandDetail.objects.get_or_create(perilous_command=pc, cmd_type="white")
                    cd_ids.append(cd[0].id)
                CommandGroup.objects.filter(pk=pk).update(**put_data.dict())
                CommandGroup.objects.get(pk=pk).command_detail.set(CommandDetail.objects.filter(id__in=cd_ids))
            elif put_data["group_type"] == "black":
                cd_ids = list()
                for pc_id in perilous_cmds:
                    pc = PerilousCommand.objects.get(id=pc_id)
                    cd = CommandDetail.objects.get_or_create(perilous_command=pc, cmd_type="perilous")
                    cd_ids.append(cd[0].id)

                for pc_id in sensitive_cmds:
                    pc = PerilousCommand.objects.get(id=pc_id)
                    cd = CommandDetail.objects.get_or_create(perilous_command=pc, cmd_type="sensitive")
                    cd_ids.append(cd[0].id)
                CommandGroup.objects.filter(pk=pk).update(**put_data.dict())
                CommandGroup.objects.get(pk=pk).command_detail.set(CommandDetail.objects.filter(id__in=cd_ids))
            else:
                res = {'code': 1, 'result': '非法调用!'}
                return self.render_json_response(res)
            res = {'code': 0, 'result': '更新成功!'}
        except Exception as e:
            res = {'code': 1, 'errmsg': '%s' % str(e)}
        return self.render_json_response(res)
Beispiel #7
0
    def put(self, request, *args, **kwargs):
        try:
            if not request.user.has_perm('auth.perm_dns_record_edit'):
                return self.render_json_response({'code': 1, 'errmsg': '权限不足,无法修改!'})
            ver, env = kwargs.get('version'), kwargs.get('env')
            post_data = QueryDict(request.body).dict()
            print(ver, post_data)
            record_id = post_data.pop('id')
            if "mx_priority" in post_data:
                if post_data['mx_priority']:
                    post_data['mx_priority'] = int(post_data['mx_priority'])
                else:
                    post_data.pop('mx_priority')
            # 保存,并记录修改日志
            old_record_info = Record.objects.using('bind_{}'.format(env)).get(id=record_id).__str__()

            Record.objects.using('bind_{}'.format(env)).filter(id=record_id).update(**post_data)
            Record.objects.using('bind_{}'.format(env)).filter(id=record_id).update(serial=F('serial') + 1)

            new_record_info = Record.objects.using('bind_{}'.format(env)).get(id=record_id).__str__()
            DnsLog.objects.create(user=request.user, action='edit', old_record=old_record_info,
                                  new_record=new_record_info)

        except KeyError:
            print(traceback.print_exc())
            return self.render_json_response({'code': 1, 'errmsg': '未找到该记录!'})
        except Record.DoesNotExist:
            return self.render_json_response({'code': 1, 'errmsg': '未找到该记录!'})
        return self.render_json_response({'code': 0, 'result': '操作成功!'})
Beispiel #8
0
def clean_state_code(url):
    r = urlparse(url)
    q = QueryDict(r.query, mutable=True)
    if "state" in q and q["state"] == STATE_PREFIX:
        q.pop("state")
        q.pop("code")
    return urlunparse([r[0], r[1], r[2], r[3], q.urlencode(), r[5]])
Beispiel #9
0
def get_extendable_request_querystring(request):
    """
    Get the query string from a request and append `&` if it exists

    If a querystring exists, it is appended with a `&` for extension.
    If no querystring exists, the return is the empty string.

    Parameters
    ----------
    request :  django.http.HttpRequest

    Returns
    -------
    str
        Verbose name of the field.
    """
    querydict = QueryDict(request.GET.urlencode(), mutable=True)
    # querydict = request.GET
    # querydict.mutable = True
    if "page" in querydict:
        querydict.pop("page")
    querystring = querydict.urlencode()
    if querystring:
        return querystring + "&"
    else:
        return ""
Beispiel #10
0
def add_asset_api(request):
    new_asset_args = QueryDict(request.body)
    tags = new_asset_args.getlist('tags')
    new_asset_args_dict = QueryDict(request.body).dict()
    new_asset_args_dict.update({"owner": request.user})
    new_asset_args_dict.pop("tags", None)
    try:
        asset = Asset(**new_asset_args_dict)
        asset.save()

        # Add categories
        for cat in tags:
            c = AssetCategory.objects.filter(value=cat).first()
            if c:
                asset.categories.add(c)
        asset.save()

        return JsonResponse(asset.to_dict())
    except Exception:
        return JsonResponse({
            'status':
            'error',
            'reason':
            'Unable to create asset with provided args.'
        })
Beispiel #11
0
    def post(self, request, **kwargs):
        res = {'code': 0}
        webdata = QueryDict(request.body).dict()
        booksdata = webdata.get('books')
        errorinfo = []  #错误信息列表
        bookobjs = []  #存在的书列表
        # 判断书是否存在,如果存在加入书列表bookobjs,如果不存在写入errorinfo列表
        for bk in json.loads(booksdata):
            try:
                obj = self.bookmodel.objects.get(name=bk)
            except self.bookmodel.DoesNotExist:
                errorinfo.append({'name': bk})
            else:
                bookobjs.append(obj)
        #如果有错误信息说明书不存在,返回错误信息
        if errorinfo:
            return JsonResponse({'code': 1, 'data': errorinfo})

        # 删掉书的元素,写作者信息
        webdata.pop('books')
        try:
            authorobj = self.model.objects.create(**webdata)
        except Basemodel as e:
            res['code'] = 1
            res['error'] = '字段不合法'
        # 写作者与书的关联关系
        for bookobj in bookobjs:
            authorobj.book_set.add(bookobj)
        return JsonResponse(res)
Beispiel #12
0
 def put(self, request, *args, **kwargs):
     try:
         ug_id = kwargs.get('ug_id')
         ugc = UserGroupCommand.objects.get_or_create(
             user_group=Group.objects.get(id=ug_id))[0]
         put_data = QueryDict(request.body, mutable=True)
         white_cmd_groups = put_data.pop(
             'white_cmd_group') if "white_cmd_group" in put_data else list(
             )
         black_cmd_groups = put_data.pop(
             'black_cmd_group') if "black_cmd_group" in put_data else list(
             )
         if put_data["group_type"] == "white":
             ugc.command_group.set(
                 CommandGroup.objects.filter(id__in=white_cmd_groups))
         elif put_data["group_type"] == "black":
             ugc.command_group.set(
                 CommandGroup.objects.filter(id__in=black_cmd_groups))
         else:
             res = {'code': 1, 'result': '非法调用!'}
             return self.render_json_response(res)
         res = {'code': 0, 'result': "更新成功"}
     except Exception as e:
         res = {'code': 1, 'errmsg': '%s' % str(e)}
     return self.render_json_response(res)
Beispiel #13
0
	def get_search_result_table(cls, request_data):
		"""Return a dict with all the necessary info to create a table of results"""
		# THIS COULD GO INTO THE VIEW
		#import pdb; pdb.set_trace()
		# Get the cleaned data from the request_data
		cleaned_data = cls.get_cleaned_data(request_data)
		
		# Get the paginator
		paginator = cls.get_paginator(cleaned_data, request_data.get("limit", GlobalConfig.get("search_result_table_size", 12)))
		
		# Get the page
		page_number = request_data.get("page", 1)
		try:
			page = paginator.page(page_number)
		except PageNotAnInteger:
			page = paginator.page(1)
		except EmptyPage:
			raise Exception("No result found for your search criteria")
		
		# Result table
		table = {'data_series_name': cls.record_table}
		
		# Make the header and rows from the page objects
		table['headers'], table['rows'] = cls.get_headers_rows(page.object_list)
		
		# Set up the pages navigation by encoding the request data with the corresponding page
		# The request data from a request is immutable, therefore we need to copy it
		query_dict = QueryDict("", mutable = True)
		query_dict.update(request_data)
		
		if page.number > 1:
			query_dict["page"] = 1
			table['first_page_url_query'] = query_dict.urlencode()
		else:
			table['first_page_url_query'] = None
		
		if page.has_previous():
			query_dict["page"] = page.previous_page_number()
			table['previous_page_url_query'] = query_dict.urlencode()
		else:
			table['previous_page_url_query'] = None
		
		if page.has_next():
			query_dict["page"] = page.next_page_number()
			table['next_page_url_query'] = query_dict.urlencode()
		else:
			table['next_page_url_query'] = None
		
		if page.number < paginator.num_pages:
			query_dict["page"] = paginator.num_pages
			table['last_page_url_query'] = query_dict.urlencode()
		else:
			table['last_page_url_query'] = None
		
		# For informative purpose we add the search query
		query_dict["page"] = None
		query_dict.pop("page")
		table['search_query'] = query_dict.urlencode()
		
		return table
def remove_query_param(url, param):
    from urllib import parse
    from django.http import QueryDict

    # parse URL
    parsed_url = parse.urlparse(url)

    # path
    path = parsed_url.path

    # params as string
    params = parsed_url.query

    # convert params string to querydict
    querydict = QueryDict(params, mutable=True)

    # remove param from querydict (if exists)
    for key, value in QueryDict(param).items():
        if key in querydict:
            querydict.pop(key)

    # encode params to string
    encoded_params = querydict.urlencode()

    # construct new path
    new_url = '{}?{}'.format(path, encoded_params)

    return new_url.strip('?')
Beispiel #15
0
def fix_sf_docstashes(apps, schema_editor):
    DocStash = apps.get_model('docstash', 'DocStash')

    stashes = DocStash.objects.filter(
        group='ecs.core.views.submissions.create_submission_form')

    for stash in stashes:
        if 'POST' in stash.value:
            post = QueryDict(stash.value['POST'], mutable=True)

            m = post.pop('subject_males', None)
            f = post.pop('subject_females', None)
            c = post.pop('subject_childbearing', None)

            post['subject_males'] = '2' if m else '3'
            if f and c:
                post['subject_females_childbearing'] = '0'
            elif f and not c:
                post['subject_females_childbearing'] = '1'
            elif not f and c:
                post['subject_females_childbearing'] = '2'
            else:
                post['subject_females_childbearing'] = '3'

            stash.value['POST'] = post.urlencode()
            stash.save()
    def get_queryset(self):
        params = self.request.query_params
        trading_desk_id = params.get('trading_desk_id')
        group_id = params.get('group_id')
        is_active = params.get('is_active')
        is_staff = params.get('is_staff')

        query_params = QueryDict('', mutable=True)
        query_params.update(params)

        if trading_desk_id is not None:
            query_params[
                'profile__trading_desk__trading_desk_id'] = trading_desk_id

        if is_active is not None:
            if 'false' == is_active:
                query_params['is_active'] = ''
            elif 'all' == is_active:
                query_params.pop('is_active')

        if is_staff is not None and 'false' == is_staff:
            query_params['is_staff'] = ''

        if group_id is not None:
            try:
                group_name = Group.objects.get(pk=int(group_id)).name
            except ObjectDoesNotExist:
                group_name = None

            query_params['groups__name'] = group_name

        self.query_params = query_params

        return super(UserList, self).get_queryset()
Beispiel #17
0
 def process_request(self, request):  # noqa D102
     if "_pjax" in request.META.get("QUERY_STRING", ""):
         qs = QueryDict(request.META.get("QUERY_STRING", ""),
                        encoding=request.encoding, mutable=True)
         qs.pop("_pjax", None)
         request.META["QUERY_STRING"] = qs.urlencode()
         request.META["PJAX"] = True
Beispiel #18
0
    def put(self, request, *args, **kwargs):
        try:
            pk, env = kwargs.get('pk'), kwargs.get('env')
            p = Record.objects.using('bind_{}'.format(env)).get(pk=pk)
            form = RecordForm(request.POST, instance=p)
            if form.is_valid():
                # 保存,并记录修改日志
                old_record_info = Record.objects.using('bind_{}'.format(env)).get(domain_name=form.instance.zone,
                                                                                  host=form.instance.host,
                                                                                  data=form.instance.data).__str__()

                post_data = QueryDict(request.body).dict()
                if "mx_priority" in post_data:
                    if post_data['mx_priority']:
                        post_data['mx_priority'] = int(post_data['mx_priority'])
                    else:
                        post_data.pop('mx_priority')
                Record.objects.using('bind_{}'.format(env)).filter(pk=pk).update(**post_data)
                Record.objects.using('bind_{}'.format(env)).filter(pk=pk).update(serial=F('serial') + 1)

                new_record_info = Record.objects.using('bind_{}'.format(env)).get(domain_name=form.instance.zone,
                                                                                  host=form.instance.host,
                                                                                  data=form.instance.data).__str__()
                DnsLog.objects.create(user=request.user, action='edit', old_record=old_record_info, new_record=new_record_info)

                res = {"code": 0, "result": "更新成功", 'next_url': self.next_url}
            else:
                res = {"code": 1, "errmsg": form.errors, 'next_url': self.next_url}
        except Exception as e:
            res = {"code": 1, "errmsg": str(e), 'next_url': self.next_url}
        return self.render_json_response(res)
Beispiel #19
0
 def post(self, request, *args, **kwargs):
     # 接受前端的数据
     rqs = QueryDict(request.body).dict()
     print request.body
     rqsbooks = rqs['books']
     books = [
         book.strip() for book in json.loads(rqsbooks)
     ]  #json.dumps是将一个Python数据类型列表进行json格式的编码解析;json.loads解码python json格式
     # 判断数在不在数据库,在的话存数据,不在返回错误信息
     errorinfo = []
     bookobjs = []
     for book in books:
         try:
             bookobj = self.bookmodel.objects.get(name=book)
         except self.bookmodel.DoesNotExist:
             errorinfo.append({'name': book})
         else:
             bookobjs.append(bookobj)
     if errorinfo:
         return JsonResponse({'status': -1, 'data': errorinfo})
     ##### 写除了书以外的字段
     rqs.pop('books')
     authorobj = self.model.objects.create(**rqs)
     #### 写作者和书的manytomay关系
     for bookobj in bookobjs:
         bookobj.author.add(authorobj)
     return JsonResponse({'status': 0})
Beispiel #20
0
def sort_url_obj(context, value, param_name='sort'):
    """生成排序的 url 对象"""
    request = context['request']
    url = request.path
    query_dict = QueryDict(
        request.GET.urlencode().encode('utf8'), mutable=True
    )

    # 更换排序顺序
    keyword = query_dict.get(param_name, '')
    if param_name in query_dict:
        query_dict.pop(param_name)
    sorting = ''  # 当前的排序情况
    new_keyword = '-' + value
    if keyword == ('-' + value):
        sorting = 'desc'
        new_keyword = value
    elif keyword == value:
        sorting = 'asc'

    # 新的 url
    extra_param = query_dict.urlencode()
    if extra_param:
        extra_param = '&' + extra_param
    new_url = "{url}?{param_name}={new_keyword}{extra_param}".format(
        url=url, param_name=param_name, new_keyword=new_keyword,
        extra_param=extra_param
    )

    return {'new_url': new_url, 'sorting': sorting}
Beispiel #21
0
 def put(self, request, *args, **kwargs):
     # rqs = request.PUT.get('name')
     bookidskey = 'bookids'
     pk = self.kwargs.get(self.pk_url_kwarg)
     rqs = QueryDict(request.body).dict()  #接受修改后的前端数据
     print rqs
     bks = rqs.get(bookidskey)
     bks = [int(bookid) for bookid in json.loads(bks)]
     if rqs.get(bookidskey):
         rqs.pop(bookidskey)  # 从字典里删除bookids,为后面修改作者数据准备
     authorbookids = [
         bk.id for bk in self.model.objects.get(pk=pk).book_set.all()
     ]  #获取修改前作者的书籍id
     print authorbookids
     diffids = list(set(authorbookids).difference(
         set(bks)))  # 求作者的书 和前端传来的书 的差集
     # 删除作者的diffids书关联
     if diffids:
         for bookid in diffids:
             bkobj = self.bookmodel.objects.get(pk=bookid)
             authorobj = self.model.objects.get(pk=pk)
             authorobj.book_set.remove(bkobj)
     # self.model.objects.filter(pk=self.kwargs.get(self.pk_url_kwarg)).update(**QueryDict(request.body).dict())
     self.model.objects.filter(
         pk=self.kwargs.get(self.pk_url_kwarg)).update(**rqs)  # 修改其它字段信息
     return JsonResponse({'status': 0})
Beispiel #22
0
def add_asset_group_api(request):
    new_assetgroup_args = QueryDict(request.body)
    tags = new_assetgroup_args.getlist('tags')
    assets = new_assetgroup_args.getlist('assets')
    new_assetgroup_args_dict = QueryDict(request.body).dict()
    new_assetgroup_args_dict.update({"owner": request.user})
    new_assetgroup_args_dict.pop("tags", None)
    new_assetgroup_args_dict.pop("assets", None)

    assetgroup = AssetGroup(**new_assetgroup_args_dict)
    assetgroup.save()

    # Add assets
    for asset in assets:
        a = Asset.objects.for_user(request.user).filter(id=asset).first()
        if a:
            assetgroup.assets.add(a)
    assetgroup.save()

    # Add categories
    for cat in tags:
        c = AssetCategory.objects.filter(value=cat).first()
        if c:
            assetgroup.categories.add(c)
    assetgroup.save()

    return JsonResponse(assetgroup.to_dict())
Beispiel #23
0
    def process_view(self, request, view_func, view_args, view_kwargs):
        user_agents_str = request.META.get('HTTP_USER_AGENT', None)

        if user_agents_str is None:
            return

        url = request.build_absolute_uri()
        user_agent = user_agents.parse(user_agents_str)
        is_mobile = user_agent.is_mobile

        logger.debug('is_mobile={}'.format(is_mobile))


        # 开发模式下,如果是用127.0.0.1:8000访问的,则只在url的querystring中加入flavor=mobile
        # TODO 考虑port不是80?
        flag_use_flavor = '8000' in request.META['HTTP_HOST'] and settings.DEBUG is True

        flavour = request.GET.get(consts.FLAVOUR_NAME, consts.PC)

        need_redirect = False

        if flag_use_flavor:
            query_string = request.META['QUERY_STRING']

            qd = QueryDict(query_string=query_string, mutable=True)

            if is_mobile and flavour == consts.PC:
                need_redirect = True
                qd[consts.FLAVOUR_NAME] = consts.MOBILE

            elif (not is_mobile) and flavour == consts.MOBILE:
                need_redirect = True
                qd.pop(consts.FLAVOUR_NAME, None)

            elif flavour not in [consts.PC, consts.MOBILE]:
                raise Exception('illegal flavour')

            logger.debug('flag_can_not_redirect|need_redirect={}'.format(need_redirect))

            if need_redirect:
                request.META['QUERY_STRING'] = qd.urlencode()
                new_url = request.build_absolute_uri()
                logger.debug('flag_can_not_redirect|new_url={}'.format(new_url))
                return HttpResponseRedirect(new_url)
            else:
                return

        new_url = url
        if user_agent.is_mobile and '//m.' not in url:
            if '//www.' in url:
                new_url = url.replace('//www.', '//m.')
            else:
                new_url = url.replace('//', '//m.')
        elif not user_agent.is_mobile and '//m.' in url:
            new_url = url.replace('//m.', '//')

        if new_url != url:
            logger.debug(u'user_agent: {}.old url: {}. new url: {}.'.format(user_agents_str, url, new_url))
            return HttpResponseRedirect(new_url)
Beispiel #24
0
def update(request,uid):
    print(uid)
    if request.method == "POST":
        data = QueryDict(request.body).dict()
        data.pop('csrfmiddlewaretoken')
        print(data)
        res = User.objects.filter(id=uid).update(**data)
    return render(request, 'hello/updateResult.html', {'res': res})
Beispiel #25
0
 def get_context_data(self, **kwargs):
     context = super(BaseRequestListView, self).get_context_data(**kwargs)
     no_page_query = QueryDict(self.request.GET.urlencode().encode('utf-8'),
                               mutable=True)
     no_page_query.pop('page', None)
     context['getvars'] = no_page_query.urlencode()
     context['menu'] = self.menu_item
     return context
def remove_data_from_url(url):
    scheme, netloc, path, query, fragment = urlsplit(url)

    qs = QueryDict(query, mutable=True)
    qs.pop('data', None)
    query = qs.urlencode(safe='/')

    return urlunsplit([scheme, netloc, path, query, fragment])
Beispiel #27
0
 def get_context_data(self, **kwargs):
     context = super(BaseRequestListView, self).get_context_data(**kwargs)
     no_page_query = QueryDict(self.request.GET.urlencode().encode('utf-8'),
                               mutable=True)
     no_page_query.pop('page', None)
     context['getvars'] = no_page_query.urlencode()
     context['menu'] = self.menu_item
     return context
Beispiel #28
0
Datei: utils.py Projekt: ria4/tln
def remove_query_param(url, attr):
    (scheme, netloc, path, params, query, fragment) = urlparse(url)
    query_dict = QueryDict(query).copy()
    try:
        query_dict.pop(attr)
    except KeyError:
        pass
    query = query_dict.urlencode(safe="/")
    return urlunparse((scheme, netloc, path, params, query, fragment))
Beispiel #29
0
 def vip_batch_modf(self, request):
     args = QueryDict(request.body).dict()
     vip_id_list = QueryDict(request.body).getlist('ipvs_vip')
     args.pop('ipvs_vip')
     try:
         IPVS_CONFIG.objects.filter(id__in=vip_id_list).update(**args)
     except Exception as ex:
         logger.error(msg="Ipvs VIP批量修改失败: {ex}".format(ex=ex))
         return "Ipvs VIP批量修改失: {ex}".format(ex=ex)
Beispiel #30
0
 def replace_query_param(self, url, attr, val):
     """ replace a query parameter in a url """
     (scheme, netloc, path, params, query, fragment) = urlparse(url)
     query_dict = QueryDict(query).copy()
     query_dict[attr] = val
     if val is False:
         query_dict.pop(attr)
     query = query_dict.urlencode()
     return urlunparse((scheme, netloc, path, params, query, fragment))
Beispiel #31
0
 def replace_query_param(self, url, attr, val):
     """ replace a query parameter in a url """
     (scheme, netloc, path, params, query, fragment) = urlparse(url)
     query_dict = QueryDict(query).copy()
     query_dict[attr] = val
     if val is False:
         query_dict.pop(attr)
     query = query_dict.urlencode()
     return urlunparse((scheme, netloc, path, params, query, fragment))
 def get_context_data(self, **kwargs):
     context = super(SearchView, self).get_context_data(**kwargs)
     context['form'] = self.form
     context['query'] = self.request.GET.get('q', '')
     no_page_query = QueryDict(self.request.GET.urlencode().encode('utf-8'),
                               mutable=True)
     no_page_query.pop('page', None)
     context['getvars'] = no_page_query.urlencode()
     return context
 def get_context_data(self, **kwargs):
     context = super(SearchView, self).get_context_data(**kwargs)
     context['form'] = self.form
     context['query'] = self.request.GET.get('q', '')
     no_page_query = QueryDict(self.request.GET.urlencode().encode('utf-8'),
                               mutable=True)
     no_page_query.pop('page', None)
     context['getvars'] = no_page_query.urlencode()
     return context
Beispiel #34
0
 def ns_batch_delete(self, request):
     args = QueryDict(request.body).dict()
     rs_id_list = QueryDict(request.body).getlist('ns_ids[]')
     args.pop('ns_ids[]')
     try:
         nameserver = IPVS_NS_CONFIG.objects.filter(id__in=rs_id_list)
         nameserver.delete()
     except Exception as ex:
         logger.error(msg="Ipvs NameServer批量删除失败: {ex}".format(ex=ex))
         return "Ipvs NameServer批量删除失败: {ex}".format(ex=ex)
Beispiel #35
0
def search(request):
    print("hello this is search function")
    print(request.body)
    if request.method == "POST":
        data = QueryDict(request.body).dict()
        print(request.method, data)
        data.pop('csrfmiddlewaretoken')
        #print(data)
        user = User.objects.filter(name__icontains = data.get('name'))
        print(user)
        return render(request, 'hello/searchResult.html',{'user': user})
Beispiel #36
0
    def put(self, request, **kwargs):
        webdata = QueryDict(request.body).dict()
        pk = kwargs.get('pk')
        bookids = webdata.get('bookids') #取出前端传过来的书的ID

        auobj = self.model.objects.get(pk=pk)
        bkqs = Book2.objects.filter(id__in=json.loads(bookids)) #取出前端传过来的书
        auobj.book2_set.set(bkqs)  #修改作者与书的关系

        webdata.pop('bookids') #从webData中移除book相关信息
        self.model.objects.filter(pk=pk).update(**webdata) #修改作者基本信息
        return JsonResponse({'status':0})
Beispiel #37
0
 def put(self, request, **kwargs):
     webdata = QueryDict(request.body).dict()
     pk = kwargs.get('pk')
     bookids = webdata.get('bookids')
     bkqs = Book.objects.filter(id__in=json.loads(bookids))
     print(bkqs)
     # 改作者和书的关系
     authorobj = self.model.objects.get(pk=pk)  # 作者对象
     authorobj.book_set.set(bkqs)  # 修改作者对象的书关系
     # 改作者数据
     webdata.pop('bookids')
     self.model.objects.filter(pk=pk).update(**webdata)
     return JsonResponse({'code': 0})
Beispiel #38
0
def add_submit(request):
    try:
        if request.method == "POST":
            data = QueryDict(request.body).dict()
            data.pop('csrfmiddlewaretoken')
            print(data)
            res = User.objects.get_or_create(**data)
            if res:
                res = 1
                return render(request,'hello/addResult.html',{'res':res})
    except:
        res = 0
        return render(request,'hello/addResult.html',{'res':res})
Beispiel #39
0
def _remove_qs(params, **kwargs):
    existing = dict(params)
    for key, value in kwargs.items():
        try:
            existing[key].remove(value)
        except (KeyError, ValueError):
            pass
        else:
            if not existing[key]:
                del existing[key]
    params = QueryDict(mutable=True)
    params.update(MultiValueDict(existing))
    params.pop('page', None)  # Changing search context, reset page.
    return params
Beispiel #40
0
def page_url(context, page_number, page_keyword="page"):
    request = context['request']
    url = request.path
    get = QueryDict(request.GET.urlencode().encode('utf8'), mutable=True)
    if page_keyword in get:
        get.pop(page_keyword)
    # 除 page 参数外的其他参数
    extra_param = get.urlencode()
    if extra_param:
        extra_param = '&' + extra_param

    return "{url}?{page_keyword}={page_number}{extra_param}".format(
        url=url, page_keyword=page_keyword, page_number=page_number,
        extra_param=extra_param
    )
Beispiel #41
0
def unpjax(url):
    """
    Removes `_pjax` param from query string of a given url::
        <a href="{{ request.get_full_path|unpjax }}"></a>
    """
    if "?" in url:
        base, qs = url.split("?", 1)
        if "_pjax" in qs:
            qs = QueryDict(qs, mutable=True)
            qs.pop("_pjax", None)
            qs = qs.urlencode()
            if qs:
                return base + "?" + qs
            return base
    return url
Beispiel #42
0
class TestCourseDetailGetForm(FormTestMixin, UsernameTestMixin, SharedModuleStoreTestCase):
    """
    Tests for CourseDetailGetForm
    """
    shard = 4
    FORM_CLASS = CourseDetailGetForm

    @classmethod
    def setUpClass(cls):
        super(TestCourseDetailGetForm, cls).setUpClass()

        cls.course = CourseFactory.create()

    def setUp(self):
        super(TestCourseDetailGetForm, self).setUp()

        self.student = UserFactory.create()
        self.set_up_data(self.student)

    def set_up_data(self, user):
        """
        Sets up the initial form data and the expected clean data.
        """
        self.initial = {'requesting_user': user}
        self.form_data = QueryDict(
            urlencode({
                'username': user.username,
                'course_key': unicode(self.course.id),
            }),
            mutable=True,
        )
        self.cleaned_data = {
            'username': user.username,
            'course_key': self.course.id,
        }

    def test_basic(self):
        self.assert_valid(self.cleaned_data)

    #-- course key --#

    def test_no_course_key_param(self):
        self.form_data.pop('course_key')
        self.assert_error('course_key', "This field is required.")

    def test_invalid_course_key(self):
        self.form_data['course_key'] = 'invalid_course_key'
        self.assert_error('course_key', "'invalid_course_key' is not a valid course key.")
Beispiel #43
0
 def test_immutability(self):
     q = QueryDict()
     with self.assertRaises(AttributeError):
         q.__setitem__("something", "bar")
     with self.assertRaises(AttributeError):
         q.setlist("foo", ["bar"])
     with self.assertRaises(AttributeError):
         q.appendlist("foo", ["bar"])
     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()
Beispiel #44
0
def ajax_add_firstdata(request):
    """
    :param request:
    :return:
    """
    data = QueryDict(request.body)
    f = FirstDataForm(data)
    if not f.is_valid():
        response = json_response_content('error', 'Form is invalid')
        for key, value in f.errors.items():
            error = {'field': key, 'message': value}
            response['errors'].append(error)
            return JsonResponse(response, safe=False)
    data = f.cleaned_data
    ps = CompanyPaymentSystem()
    ps.payment_system_id = data.pop('ps_id')

    if request.user.is_focus:
        company_id = int(request.POST.get('f_company_id', 1))
        company = request.db_session.query(Company).get(company_id)
    else:
        company = request.user.company

    ps.company = company
    ps.user = request.user

    fd = FirstData(**data)
    fd.company_payment_system = ps
    request.db_session.add_all([fd, ps])

    response = json_response_content('success', 'Account added successfully')
    return JsonResponse(response, safe=False)
Beispiel #45
0
 def test_immutability(self):
     q = QueryDict()
     with self.assertRaises(AttributeError):
         q.__setitem__('something', 'bar')
     with self.assertRaises(AttributeError):
         q.setlist('foo', ['bar'])
     with self.assertRaises(AttributeError):
         q.appendlist('foo', ['bar'])
     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()
Beispiel #46
0
    def test_single_key_value(self):
        """Test QueryDict with one key/value pair"""

        q = QueryDict(str("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"])

        if six.PY2:
            self.assertTrue(q.has_key("foo"))
        self.assertIn("foo", q)
        if six.PY2:
            self.assertFalse(q.has_key("bar"))
        self.assertNotIn("bar", q)

        self.assertEqual(list(six.iteritems(q)), [("foo", "bar")])
        self.assertEqual(list(six.iterlists(q)), [("foo", ["bar"])])
        self.assertEqual(list(six.iterkeys(q)), ["foo"])
        self.assertEqual(list(six.itervalues(q)), ["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 #47
0
    def test_single_key_value(self):
        """Test QueryDict with one key/value pair"""

        q = QueryDict(str('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'])

        if six.PY2:
            self.assertTrue(q.has_key('foo'))
        self.assertIn('foo', q)
        if six.PY2:
            self.assertFalse(q.has_key('bar'))
        self.assertNotIn('bar', q)

        self.assertEqual(list(six.iteritems(q)), [('foo', 'bar')])
        self.assertEqual(list(six.iterlists(q)), [('foo', ['bar'])])
        self.assertEqual(list(six.iterkeys(q)), ['foo'])
        self.assertEqual(list(six.itervalues(q)), ['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 #48
0
    def test_multiple_keys(self):
        """Test QueryDict with two key/value pairs with same keys."""

        q = QueryDict(str("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"])

        if six.PY2:
            self.assertEqual(q.has_key("vote"), True)
        self.assertEqual("vote" in q, True)
        if six.PY2:
            self.assertEqual(q.has_key("foo"), False)
        self.assertEqual("foo" in q, False)
        self.assertEqual(list(six.iteritems(q)), [("vote", "no")])
        self.assertEqual(list(six.iterlists(q)), [("vote", ["yes", "no"])])
        self.assertEqual(list(six.iterkeys(q)), ["vote"])
        self.assertEqual(list(six.itervalues(q)), ["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 #49
0
    def test_multiple_keys(self):
        """Test QueryDict with two key/value pairs with same keys."""

        q = QueryDict(str('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'])

        if six.PY2:
            self.assertIs(q.has_key('vote'), True)
        self.assertIn('vote', q)
        if six.PY2:
            self.assertIs(q.has_key('foo'), False)
        self.assertNotIn('foo', q)
        self.assertEqual(list(six.iteritems(q)), [('vote', 'no')])
        self.assertEqual(list(six.iterlists(q)), [('vote', ['yes', 'no'])])
        self.assertEqual(list(six.iterkeys(q)), ['vote'])
        self.assertEqual(list(six.itervalues(q)), ['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 #50
0
def query_dict(querystring, exclude):
    qdict = QueryDict(querystring).copy()
    query_string = str()

    if type(exclude) != tuple:
        raise Exception("exclude must be a tuple")

    for item in exclude:
        if item in qdict:
            qdict.pop(item)

    query_dict_urlencode = qdict.urlencode() 

    if query_dict_urlencode != '':
        query_string = query_dict_urlencode + "&"

    query_string.replace('&', '&amp;')

    return query_string
Beispiel #51
0
    def test_basic_mutable_operations(self):
        q = QueryDict(str('')).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')
        if not six.PY3:
            self.assertTrue(q.has_key('foo'))
        self.assertTrue('foo' in q)

        self.assertEqual(sorted(list(six.iteritems(q))),
                         [('foo', 'another'), ('name', 'john')])
        self.assertEqual(sorted(list(six.iterlists(q))),
                         [('foo', ['bar', 'baz', 'another']), ('name', ['john'])])
        self.assertEqual(sorted(list(six.iterkeys(q))),
                         ['foo', 'name'])
        self.assertEqual(sorted(list(six.itervalues(q))),
                         ['another', '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'), ['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 #52
0
 def clean_search(self):
     # Remove all empty elements of search field
     # Django `QueryDict` uses keep_blank_values=True
     # in parse_qsl that keeps empty values as [u'']
     # which is not in our use case
     # Below, we remove these values, and only keep setted ones.
     data = self.cleaned_data['search']
     q = QueryDict(data, mutable=True)
     [q.pop(elt[0]) for elt in q.lists() if elt[1] == [u'']]
     return q.urlencode()
Beispiel #53
0
class ThreadListGetFormTest(FormTestMixin, PaginationTestMixin, TestCase):
    """Tests for ThreadListGetForm"""
    FORM_CLASS = ThreadListGetForm

    def setUp(self):
        super(ThreadListGetFormTest, self).setUp()
        self.form_data = QueryDict(
            urlencode(
                {
                    "course_id": "Foo/Bar/Baz",
                    "page": "2",
                    "page_size": "13",
                }
            ),
            mutable=True
        )

    def test_basic(self):
        self.form_data.setlist("topic_id", ["example topic_id", "example 2nd topic_id"])
        form = self.get_form(expected_valid=True)
        self.assertEqual(
            form.cleaned_data,
            {
                "course_id": CourseLocator.from_string("Foo/Bar/Baz"),
                "page": 2,
                "page_size": 13,
                "topic_id": ["example topic_id", "example 2nd topic_id"],
            }
        )

    def test_missing_course_id(self):
        self.form_data.pop("course_id")
        self.assert_error("course_id", "This field is required.")

    def test_invalid_course_id(self):
        self.form_data["course_id"] = "invalid course id"
        self.assert_error("course_id", "'invalid course id' is not a valid course id")

    def test_empty_topic_id(self):
        self.form_data.setlist("topic_id", ["", "not empty"])
        self.assert_error("topic_id", "This field cannot be empty.")
Beispiel #54
0
    def extra_context(self):
        getvars = QueryDict(self.request.GET.urlencode(), mutable=True)
        try:
            getvars.pop("page")
        except KeyError:
            pass
        getvars = getvars.urlencode()

        show_galleries_tree = False
        if self.form.is_valid():
            if self.form.cleaned_data.get('search_galleries_choice', None) == "SELECTED":
                show_galleries_tree = True

        no_image_thumb_url = os.path.join(settings.STATIC_URL,
                                          settings.DAG_NO_IMAGE[settings.DAG_GALLERY_THUMB_SIZE_KEY])

        return {'no_image_thumb_url': no_image_thumb_url,
                'search_options_form': self.form,
                'show_galleries_tree': show_galleries_tree,
                'getvars': getvars,
                }
    def render(self, context):
        if 'request' not in context:
            return ""

        request = context['request']

        result = {}

        if self.copy:
            result = request.GET.copy()
        else:
            result = QueryDict("", mutable=True)

        if self.nopage:
            result.pop("page", None)

        for key, newvalue in self.changes:
            newvalue = newvalue.resolve(context)
            result[key] = newvalue

        return "?" + result.urlencode()
Beispiel #56
0
    def test_basic_mutable_operations(self):
        q = QueryDict(str("")).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")
        if not six.PY3:
            self.assertTrue(q.has_key("foo"))
        self.assertTrue("foo" in q)

        self.assertEqual(list(six.iteritems(q)), [("foo", "another"), ("name", "john")])
        self.assertEqual(list(six.iterlists(q)), [("foo", ["bar", "baz", "another"]), ("name", ["john"])])
        self.assertEqual(list(six.iterkeys(q)), ["foo", "name"])
        self.assertEqual(list(six.itervalues(q)), ["another", "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"), ["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.assertEqual(q.urlencode(), "foo=bar&name=john")

        q.clear()
        self.assertEqual(len(q), 0)
    def render(self, context):
        original_querystring = self.original_querystring.resolve(context)

        if isinstance(original_querystring, QueryDict):
            qs = original_querystring.copy()
        else:
            qs = QueryDict(original_querystring, mutable=True)

        qs.pop("page", None)

        key = self.key
        val = self.value

        if not (key[0] == key[-1] == '"'):
            key = Variable(key).resolve(context)
        else:
            key = key.strip('"')

        if not (val[0] == val[-1] == '"'):
            val = Variable(val).resolve(context)
        else:
            val = val.strip('"')

        field_values = qs.getlist(key)

        if self.mode == "add":
            field_values.append(val)
        else:
            if val in field_values:
                field_values.remove(val)

        qs.setlist(key, field_values)

        output = escape(qs.urlencode())

        if self.output_variable_name:
            context[self.output_variable_name] = output
        else:
            return output
Beispiel #58
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 #59
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 #60
0
    def filter_dataset(self, settings, dataset=None):
        if settings.filter_dataset and settings.filter_querystring:
            params = QueryDict(settings.filter_querystring).dict()
            orders = params.pop('o', '').split('.')
            fields = params.pop('fields', '').split(',')

            for ignore in IGNORED_PARAMS:
                params.pop(ignore, None)

            if not dataset:
                return params

            dataset = dataset.filter(**params)

            if '' not in orders and '' not in fields:
                ordering = []
                for order in orders:
                    field = fields[abs(int(order))]
                    if int(order) < 0:
                        field = '-{}'.format(field)
                    ordering.append(field)
                dataset = dataset.order_by(*ordering)

        return dataset