def dispatch(self, request, *args, **kwargs): assert self.forward_group is not None, \ 'ForwardMixin subclasses need to set a forward_group.' if self.should_forward(request, *args, **kwargs): redirect_response = self.get_redirect_response( request, *args, **kwargs) if request.method == 'POST' and request.POST: redirect_response = self.create_forward( request=request, response=redirect_response) return redirect_response forward_id = request.COOKIES.get('forward') if forward_id is not None: try: forward = Forward.objects.get(id=forward_id) forward_data = QueryDict('', mutable=True) forward_data.update(json.loads(forward.json)) request.forward_data = forward_data Forward.objects.filter( Q(created_at__gt=timezone.now() + timedelta(days=1)) | Q(pk=forward.pk)).delete() except Forward.DoesNotExist: pass return super().dispatch(request, *args, **kwargs)
def get_feedback_filter_params(self): # We need to be careful here because some of the filter_form params # are for FRs not the nested Feedback. If we include those and then # we edit the FR in a way where it no longer matches the params we'll # get a 404 as we'll exclude ourself. Given that we only want to pass # along params that are for Feedback. params_to_exclude = ( "search", "state", "theme", "priority", "effort", "shipped_start_date", "shipped_end_date", "shipped_date_range", ) filter_dict = self.get_filter_form().data qd = QueryDict(mutable=True) qd.update(filter_dict) for param_name in params_to_exclude: if param_name in qd: qd.pop(param_name) # HACK: there is surely a better way but the form returns empty values # here as None but when we urlencode that we get 'None'. DateField # doesn't like 'None' b/c it's not a valid date. So... here we just # turn None into '' which the form is happy with. if qd.get("feedback_date_range", None) is None: qd["feedback_date_range"] = "" if qd.get("feedback_start_date", None) is None: qd["feedback_start_date"] = "" if qd.get("feedback_end_date", None) is None: qd["feedback_end_date"] = "" return qd
def create(self, request): if request.method == 'POST': data = dict(request.data) #print(request.data) if len(data['calorie'][0]) == 0 or float( data['calorie'][0]) == float(0): flag, val = nutritionnix_calorie_api(data['food_name'][0]) if flag: data['calorie'][0] = val else: return Response(status=status.HTTP_400_BAD_REQUEST) query_dict = QueryDict('', mutable=True) query_dict.update(MultiValueDict(data)) serializer = MealSerializer(data=query_dict) if serializer.is_valid(): try: user = UserProfile.objects.get(pk=self.request.user.id) user.curr_calorie += float(data['calorie'][0]) if user.curr_calorie < user.max_calorie: user.is_limit = False else: user.is_limit = True user.save() except: return Response(status=status.HTTP_404_NOT_FOUND) serializer.save(user_profile=self.request.user) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def urlencode(self): """Return a URL encoded GET string""" def convert_date(date): """Get date into correct format""" if date is None: return "" else: return date.strftime("%m/%d/%Y") params = QueryDict("", mutable=True) min_pages = self.min_pages if self.min_pages is not None else "" min_date = convert_date(self.min_date) max_date = convert_date(self.max_date) params.update( { "q": self.query, "status": self.status, "has_embargo": self.embargo, "has_crowdfund": self.exclude_crowdfund, "minimum_pages": min_pages, "date_range_0": min_date, "date_range_1": max_date, "search_title": self.title, } ) params.setlist("user", self.users.values_list("pk", flat=True)) params.setlist("agency", self.agencies.values_list("pk", flat=True)) params.setlist("projects", self.projects.values_list("pk", flat=True)) params.setlist("tags", self.tags.values_list("pk", flat=True)) params.setlist( "jurisdiction", [str(j) for j in self.searchjurisdiction_set.all()] ) return params.urlencode()
def get_form_kwargs(self): kwargs = super(RegistrationView, self).get_form_kwargs() self.ax = self.request.session['ax'] if not self.ax: self.ax = RegistrationView.get_ax(self.request.POST) if self.ax: ax_data = { 'first_name' : self.ax['firstname'].split(maxsplit=1)[0] if 'firstname' in self.ax.keys() else None, 'last_name' : self.ax['lastname'] if 'lastname' in self.ax.keys() else None, 'gender' : self.ax['gender'] if 'gender' in self.ax.keys() else None, 'street' : self.ax['address'] if 'address' in self.ax.keys() else None, 'town' : self.ax['city'] if 'city' in self.ax.keys() else None, 'zip' : self.ax['postal_code'] if 'postal_code' in self.ax.keys() else None, 'birthday_day' : self.ax['birth_day'] if 'birth_day' in self.ax.keys() else None, 'birthday_month' : self.ax['birth_month'] if 'birth_month' in self.ax.keys() else None, 'birthday_year' : self.ax['birth_year'] if 'birth_year' in self.ax.keys() else None } data = QueryDict('', mutable=True) data.update(ax_data) if 'data' in kwargs.keys(): data.update(kwargs['data']) kwargs['data'] = data kwargs.update({'eid' : True}) self.eid = True else: kwargs.update({'eid' : False}) self.request.session['ax'] = self.ax return kwargs
def index(request): if request.method == 'POST': vars = {k: request.POST[k].strip().lower() for k in ['material', 'item', 'transport', 'origin', 'destination']} post = QueryDict('', mutable=True) post.update(vars) return redirect('/qr?' + post.urlencode()) return render(request, 'index.html', {'form': QRCodeRequestForm()})
def fill_form(get_new_package_name, get_new_tag_name, get_new_name): package_name = next(get_new_package_name) tag_name = next(get_new_tag_name) user1_name = next(get_new_name) user1 = User.objects.create_user(username=user1_name, password=G.default_password) user1.save() user2_name = next(get_new_name) user2 = User.objects.create_user(username=user2_name, password=G.default_password) user2.save() tag = Tag.objects.create(name=tag_name, owner_id=user2.id, owner=user2) tag.save() data = { 'owner': [user1.id], 'name': [package_name], 'proficiency_value': ['1'], 'proficiency_target': ['100'], 'public': ['on'], 'ref_url': ['https://www.djangoproject.com/'], 'summary': ['<p>asdasd</p>'], 'usage_notes': ['<p>To start server call: manage.py runserver</p>'], 'tags': [tag.id], 'resources': [], 'codes': [] } form_data = QueryDict('', mutable=True) form_data.update(MultiValueDict(data)) return PackageForm(data=form_data, current_user=user1), tag.id, user1
def urlencode(self): """Return a URL encoded GET string""" def convert_date(date): """Get date into correct format""" if date is None: return '' else: return date.strftime('%m/%d/%Y') params = QueryDict('', mutable=True) min_pages = self.min_pages if self.min_pages is not None else '' min_date = convert_date(self.min_date) max_date = convert_date(self.max_date) params.update({ 'q': self.query, 'status': self.status, 'has_embargo': self.embargo, 'has_crowdfund': self.exclude_crowdfund, 'minimum_pages': min_pages, 'date_range_0': min_date, 'date_range_1': max_date, 'search_title': self.title, }) params.setlist('user', self.users.values_list('pk', flat=True)) params.setlist('agency', self.agencies.values_list('pk', flat=True)) params.setlist('projects', self.projects.values_list('pk', flat=True)) params.setlist('tags', self.tags.values_list('pk', flat=True)) params.setlist( 'jurisdiction', [unicode(j) for j in self.searchjurisdiction_set.all()], ) return params.urlencode()
def process_request(self, request): if 'application/json' in request.META['CONTENT_TYPE']: # load the json data data = json.loads(request.body) # for consistency sake, we want to return # a Django QueryDict and not a plain Dict. # The primary difference is that the QueryDict stores # every value in a list and is, by default, immutable. # The primary issue is making sure that list values are # properly inserted into the QueryDict. If we simply # do a q_data.update(data), any list values will be wrapped # in another list. By iterating through the list and updating # for each value, we get the expected result of a single list. q_data = QueryDict('', mutable=True) for key, value in data.iteritems(): if isinstance(value, list): # need to iterate through the list and upate # so that the list does not get wrapped in an # additional list. for x in value: q_data.update({key: x}) else: q_data.update({key: value}) if request.method == 'GET': request.GET = q_data if request.method == 'POST': request.POST = q_data return None
def get_task(request): msg, username = '', '' QueryDict_ask = QueryDict('', mutable=True) if request.method == 'POST': if 'username' in request.session: username = str(request.session['username']) request.POST._mutable = True # need change to mutable QueryDict_ask = request.POST QueryDict_ask.update({'username': username}) form = QuestionPostForm(QueryDict_ask, request.FILES) else: msg = '請先登入 login first please' print('login first') return render(request, 'forum/get_task.html', {'msg': msg}) if form.is_valid(): form = form.save() request_id = form.id form.save() # ch state from null to open, wait set default value query = QuestionPost.objects.filter(id=request_id) query.update(state='open') url = reverse('forum:detail_task', kwargs={'question_url_id': request_id}) return HttpResponseRedirect(url) else: print('is_valid() failed') else: print('provide form') form = QuestionPostForm() return render(request, 'forum/get_task.html', {'form': form})
def host_add(request): if not request.user.has_perm('cmdb.add_host'): raise PermissionDenied t = request.GET.get('t', '2') # 资产类型ID active = 'cmdb_host_1_active' if t == '1' else 'cmdb_host_2_active' context = {active: 'active'} if request.method == 'POST': # import ipdb;ipdb.set_trace() newhost = QueryDict(mutable=True) newhost.update(request.POST) newhost.update({'asset_type': t}) form = HostForm(newhost) if form.is_valid(): form.save() ref_url = request.POST.get('ref_url', '/') return redirect(ref_url) else: form = HostForm() ref_url = request.META.get('HTTP_REFERER', '/') # 来源URL,供POST成功后返回 context.update({'ref_url': ref_url}) context.update({'form': form}) html = 'host_2.html' return render(request, html, context)
def auto_publish(request, category_id=3): with open("/home/david/htdocs/feedback_django/example/spirit/topic/json/O.json","r",encoding='UTF-8') as file: jsonContent = json.load(file) # print(jsonContent['course'][0]) # <QueryDict: {'comment': ['f**k'], 'category': ['5'], 'csrfmiddlewaretoken': ['TrhHjnBCe5pAHjeSKGN4n3kbY3m7SvXh'], 'title': ['auto']}> jsondict = {'category': ['3'], 'comment': ['this is test'], 'csrfmiddlewaretoken': ['TrhHjnBCe5pAHjeSKGN4n3kbY3m7SvXh'], 'title': ['json works']} qdict = QueryDict('',mutable=True) qdict.update(jsondict) if category_id: get_object_or_404(Category.objects.visible(), pk=category_id) form = TopicForm(user=request.user, data=qdict) cform = CommentForm(user=request.user, data=qdict) print(form) print(form.is_valid()) print(cform.is_valid()) if all([form.is_valid(), cform.is_valid()]): # TODO: test! # wrap in transaction.atomic? topic = form.save() cform.topic = topic comment = cform.save() comment_posted(comment=comment, mentions=cform.mentions) return redirect(topic.get_absolute_url()) context = { 'form': form, 'cform': cform } return render(request, 'spirit/topic/publish.html', context)
def post(self, request, *args, **kwargs): try: images = request.FILES query_images = QueryDict("", mutable=True) query_images.update(images) images_list = query_images.getlist("photo") for photo in images_list: imgstr = base64.b64encode(photo.file.read()) album = ImageAlbum.objects.get(id=request.data["album_id"]) image = upload_image(imgstr, str(photo)) imageCDN_obj = ImageCDN.objects.create( album=album, file_id=image["fileId"], name=image["name"], url=image["url"], thumbnail=image["thumbnailUrl"], file_type=image["fileType"]) images_CDN = ImageCDN.objects.all().order_by( "id").reverse()[:len(images_list)] return Response(ImageCDNSerializer(reversed(images_CDN), many=True).data, status=status.HTTP_201_CREATED) except: return Response( ImageCDNSerializer(status=status.HTTP_400_BAD_REQUEST))
def test_ds_response_3(self): """ Testing that it works with get data from an advanced search """ get_dic = { 'search_name': 'wha%', 'search_pi': 'jame%', 'from_date_year': '2015', 'from_date_month': '11', 'from_date_day': '19', 'to_date_year': '2015', 'to_date_month': '11', 'to_date_day': '22', } response = self.client.get('/experimentsearch/data_source/What is up/', get_dic) from_get = QueryDict(mutable=True) from_get.update(get_dic) self.assertEqual(QueryDict(query_string=response.context['from_dic']), from_get) self.assertTemplateUsed(response, 'experimentsearch/datasource.html') expected_table = DataSourceTable(ds_table_set) actual_table = response.context['table'] self.check_tables_equal(actual_table, expected_table, DataSourceForTable)
def save_quick_search(request): search_name = request.POST.get('search_name', '') user_search = {} search_filters = { 'name', 'product_business', 'business_area', 'analytic_focus', 'provider_focus', 'utilization_category' } filter_empty = True for item in search_filters: user_search[item] = list(request.POST.get(item, '').split(',')) if request.POST.get(item, ''): filter_empty = False asset_list = AssetCatalog.objects.all() total_assets = asset_list.count() query_dict = QueryDict('', mutable=True) query_dict.update(MultiValueDict(user_search)) asset_filter = AssetFilter(query_dict, queryset=asset_list) if not search_name: messages.warning( request, 'Saving QUICK SEARCH: Please, provide a name for this quick search!' ) elif filter_empty: messages.warning( request, 'Saving QUICK SEARCH: Please, add some filter to this quick search!' ) else: previous_search = AssetUserSearch.objects.filter( name=search_name, user=request.user.profile) if previous_search.exists(): messages.warning( request, 'Saving QUICK SEARCH: You already have a saved search using this name.' ) else: search_text = json.dumps(user_search) new_search = AssetUserSearch.objects.create( name=search_name, user=request.user.profile, search_criteria=search_text) if new_search: print('Done') messages.success( request, 'Saving QUICK SEARCH: Your search was saved successfully!') return render( request, 'asset_mgmt/asset.html', { 'filter': asset_filter, 'product_name': request.POST.get('tag_search', ''), 'type_asset': '', 'total': total_assets, 'messages': 'OK' })
def get_url(self, viewname, arguments=None, query_args=None): arguments = arguments or {} query_args = query_args or {} query_dict = QueryDict(mutable=True) query_dict.update(**query_args) return '{url}?{query}'.format(url=reverse(viewname=viewname, kwargs=arguments), query=query_dict.urlencode())
def get_contributions_url(self, obj): if not obj.contributions: # don't add anything when it's not set. return obj.contributions parts = urlsplit(obj.contributions) query = QueryDict(parts.query, mutable=True) query.update(amo.CONTRIBUTE_UTM_PARAMS) return urlunsplit((parts.scheme, parts.netloc, parts.path, query.urlencode(), parts.fragment))
def test_filter_query_string(self): """ Test the filter query string definition. """ test_dict = {'test': '1'} query_dict = QueryDict('', mutable=True) query_dict.update(test_dict) new_query_string = filter_query_string(query_dict) self.assertEqual(new_query_string, '&test=1')
def format_filter(self, obj): qd = QueryDict(mutable=True) filter_fields = self.filter.keys() for field_name in filter_fields: qd.update({ '[{}]'.format(field_name): self.lookup_attribute(obj, self.filter[field_name]) }) return qd.urlencode(safe=['[', ']'])
def encode_query(querydict): """ Encode a querydict as form params, using '+'' for ' '. """ if not isinstance(querydict, QueryDict): temp = querydict querydict = QueryDict('', mutable=True) querydict.update(temp) return querydict.urlencode(': ').replace(' ', '+')
def query_string_from_dict(qs_dict): qs_prepared_dict = OrderedDict() for key, val in qs_dict.items(): if isinstance(val, list): val = '[%s]' % ','.join([force_text(v) for v in val]) qs_prepared_dict[key] = val qdict = QueryDict('').copy() qdict.update(qs_prepared_dict) return qdict.urlencode()
def render_text(self): soup = BeautifulSoup(self.text, 'html.parser') for a in soup.find_all('a'): if 'href' in a.attrs: querydict = QueryDict(mutable=True) querydict.update(notification=self.id, url=a['href']) wrapped_url = '%s?%s' % (reverse('notification_link_click'), querydict.urlencode()) a['href'] = wrapped_url return unicode(soup)
def dispatch(self, request, *args, **kwargs): list_filter = None list_slug = kwargs.get('listslug', None) if list_slug: list_filter = { 'slug': list_slug, 'group__slug': kwargs.get('group'), 'group__portal': CosinnusPortal.get_current() } elif request.method == 'GET': # if we navigate to the index, redirect to the default todolist instead, if it exists default_todolist_slug = settings.COSINNUS_TODO_DEFAULT_TODOLIST_SLUG default_list_filter = { 'slug': default_todolist_slug, 'group__slug': kwargs.get('group'), 'group__portal': CosinnusPortal.get_current() } default_todolist = get_object_or_None(TodoList, **default_list_filter) if default_todolist: return redirect( group_aware_reverse('cosinnus:todo:list-list', kwargs={ 'group': kwargs.get('group'), 'listslug': default_todolist.slug })) if list_filter: self.todolist = get_object_or_404(TodoList, **list_filter) else: self.todolist = None todo_slug = kwargs.get('todoslug', None) if todo_slug: self.todo = get_object_or_404( TodoEntry, slug=todo_slug, group__slug=kwargs.get('group'), group__portal=CosinnusPortal.get_current()) else: self.todo = None # default filter for todos is completed=False if not 'is_completed' in request.GET: qdict = QueryDict('', mutable=True) qdict.update(request.GET) qdict.update( {'is_completed': 0} ) # set this to '0' instead of 0 to show the "active filter" bubble request.GET = qdict ret = super(TodoListCreateView, self).dispatch(request, *args, **kwargs) return ret
def generate_link(search_param_parser, offset_prediction): """ Generate next/previous URL links Args: search_param_parser(SearchParamParser): Parsed Request Search Object offset_prediction: offset prediction number Returns: URL for next/previous links (string) """ query_temp = QueryDict(mutable=True) query_temp.update({'search': search_param_parser.search_string}) query_temp.update({'offset': offset_prediction}) query_temp.update({'limit': search_param_parser.limit}) # Limit stays the same [ query_temp.update({'category': current_category}) for current_category in search_param_parser.categories ] [ query_temp.update({'agency': current_category}) for current_category in search_param_parser.agencies ] [ query_temp.update({'type': current_category}) for current_category in search_param_parser.listing_types ] return '{!s}/api/listings/essearch/?{!s}'.format( search_param_parser.base_url, query_temp.urlencode())
def create_campaigns_through_csv(csvfile): message = '' columns = 3 Campaigns_list = [] errors = [] for index, line in enumerate(csv.reader(csvfile)): if len(line) != columns: return 'Incorrect columns structure. It must contains 3 columns and be in profile_id , notes, name format.' customer, notes, name = line campaign = {} campaign['name'] = name campaign['notes'] = notes campaign['customer'] = customer if campaign['customer']: if not Profile.objects.filter(id=campaign['customer']).exists(): return 'Profile for Id: {} - wasn\'t found.\n' \ .format( campaign['customer']) else: campaign['customer'] = Profile.objects.get( id=campaign['customer']) else: return 'Please provide profile id.' data = QueryDict('', mutable=True) data.update(campaign) form = CampaignsAddForm(data) if not form.is_valid(): errors.append( 'Row: {} Followed errors has been found in file: {}\n'.format( index + 1, ', '.join('{}: {}'.format(field, ', '.join(error)) for field, error in form.errors.iteritems()))) else: campaign['name'] = form.cleaned_data['name'] campaign['notes'] = form.cleaned_data['notes'] Campaigns_list.append(campaign) if errors: return '\n'.join(errors) for camp in Campaigns_list: message += 'Creating Campaign for {}... \n'.format(camp['name']) Campaigns.objects.create(customer=camp['customer'], name=camp['name'], notes=camp['notes']) message += 'Created Campaign: {} successfully\n'.format(camp['name']) message += '==================================================\n' return message
def filter_queryset(self, queryset): """Given a queryset, filter it, returning a new queryset.""" keys = self.request.DESCRIPTOR.fields_by_name.keys() request = HttpRequest() query_params = QueryDict('', mutable=True) query_params.update( MessageToDict(self.request, preserving_proto_field_name=True)) request.query_params = query_params for backend in list(self.filter_backends): queryset = backend().filter_queryset(request, queryset, self) return queryset
def on_user_logged_out(sender, request, user, **kwargs): if not settings.AUTH_OPENID: return if not settings.AUTH_OPENID_SHARE_SESSION: return query = QueryDict('', mutable=True) query.update({'redirect_uri': settings.BASE_SITE_URL}) client = new_client() openid_logout_url = "%s?%s" % (client.get_url_end_session_endpoint(), query.urlencode()) request.COOKIES['next'] = openid_logout_url
def _setupRequestData(value_dict): if len(value_dict) == 0: return QueryDict() qd = QueryDict(mutable=True) for key in value_dict.keys(): val = value_dict[key] if type(val) == list: for item in val: qd.update({key: item}) else: qd.update({key: val}) return qd
def post(self, req, *args, **kwargs): print("test_ini") # get requested data new_data = req.data.dict() # requested file object file_name = req.data['file_name'] date = req.data['date'] # create full path for saving file new_file_full_name = file_upload_path(file_name.name) # new file path file_path = '/'.join(new_file_full_name.split('/')[0:-1]) # file extension file_ext = os.path.splitext(file_name.name)[1] # add new data to QueryDict(for mapping with DB) new_data['file_ext'] = file_ext new_data['is_img'] = is_image(file_ext) new_data['file_path'] = file_path new_data['file_origin_name'] = req.data['file_name'].name new_data['file_save_name'] = req.data['file_name'] new_query_dict = QueryDict('', mutable=True) new_query_dict.update(new_data) celery_scan = CeleryScan(json_results='', is_complete=False) celery_scan.save() id_no = celery_scan.id_key file_serializer = FileSerializer(data=new_query_dict) print("test1") if file_serializer.is_valid(): print("test2") file_serializer.save() print("save complete") print(file_serializer.data) # create the object so scan can be applied result = scan_code_async.delay( file_serializer.data['file_save_name'], date, id_no) # return the response as HttpResponse url = 'loaclhost:8000/taejo_api_result/' + str(id_no) return Response({"url": url}, status=status.HTTP_200_OK) else: log_util.error(__name__, file_serializer.errors) return Response(file_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def send(self, url, message_data, **kwargs): qs = QueryDict(mutable=True) qs.update(message_data) r = urllib.request.urlopen(urllib.request.Request( url, qs.urlencode().encode('utf-8'), )) result = r.read().decode('utf-8') return self.validate(r.headers['content-type'], result, message_data)
def setUp(self): ProgrammeType.objects.create(display_name="Design", description="Some description text", id=1) query = QueryDict(mutable=True) query.update({ "CompanyID": "ROYALC9RCH", "courseIDs": 1, "venueIDs": "", "categoryIDs": "", }) self.query = query.urlencode()
def __init__(self, *args, **kwargs): super(AutoManagementFormMixin, self).__init__(*args, **kwargs) if self.is_bound: if isinstance(self.data, MergeDict): data = QueryDict(None, mutable=True) for d in self.data.dicts: data._encoding = d._encoding data.update(d) self.data = data # Make data mutable elif not getattr(self.data, '_mutable', True): self.data = self.data.copy() # Make data mutable
def query_params(self): orignal_params = super(BlendedRequest, self).query_params if self._params_prefix: params = QueryDict(mutable=True) params.update({k[len(self._params_prefix):]: v for k, v in orignal_params.items() if k.startswith(self._params_prefix)}) else: params = super(BlendedRequest, self).query_params for m_k, m_v in self._mapped_params.items(): for o_k, o_v in orignal_params.items(): matches = re.match(m_v, o_k) if matches: params[''.join([m_k, (matches.group(1) if matches.lastindex >= 1 else '')])] = o_v return params
def post(self, request): data = {**request.data} data.update({'user': [request.user.id]}) query_dict = QueryDict('', mutable=True) query_dict.update(MultiValueDict(data)) serializer = serializers.PlantSerializer(data=query_dict) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_chain_setup_saves_chains_correctly(self): request = HttpRequest() request.method = 'POST' request.session = self.engine.SessionStore(None) request.session['pdb_id'] = '1SC1' request.session['all_chains'] = ['A', 'B'] _dict = {'chains' : 'A'} _qdict = QueryDict('', mutable=True) _qdict.update(_dict) request.POST = _qdict response = chain_setup(request) self.assertEqual(request.session.get('included_chains'), ['A']) self.assertEqual(request.session.get('removed_chains'), ['B'])
def render(self, context): request = context['request'] # Make request.GET mutable. # request.GET = dict(request.GET) if self.var_name in request.GET: return '' else: mydict = {self.var_name : 1} qdict = QueryDict('') qdict = request.GET.copy() qdict.update(mydict) request.GET = qdict # request.GET[self.var_name] = 1 return self.nodelist.render(context)
def on_user_logged_out(sender, request, user, **kwargs): if not settings.AUTH_OPENID: return query = QueryDict('', mutable=True) query.update({ 'redirect_uri': settings.BASE_SITE_URL }) openid_logout_url = "%s?%s" % ( client.openid_connect_client.get_url( name='end_session_endpoint'), query.urlencode() ) request.COOKIES['next'] = openid_logout_url
def test_source_setup_stores_source_residues_to_session_variable(self): request = HttpRequest() request.method = 'POST' request.session = self.engine.SessionStore(None) request.session['pdb_id'] = '1SC1' request.session['chains'] = ['A', 'B'] request.session['hetatms'] = [('PHQ', 'C', '1'), ('CF0', 'C', '5')] request.session['residue_list'] = [('125', 'A'), ('126', 'A')] _dict = {'residues' : '0'} _qdict = QueryDict('', mutable=True) _qdict.update(_dict) request.POST = _qdict response = source_setup(request) self.assertEqual(request.session.get('source_residues')[0], ('125', 'A'))
def format_filter(self, obj): qd = QueryDict(mutable=True) filter_fields = self.filter.keys() for field_name in filter_fields: try: # check if serializer method passed in serializer_method = getattr(self.parent, self.filter[field_name]) except AttributeError: value = self.lookup_attribute(obj, self.filter[field_name]) else: value = serializer_method(obj) if not value: continue qd.update({'[{}]'.format(field_name): value}) if not qd.keys(): return None return qd.urlencode(safe=['[', ']'])
def test_hetatm_setup_saves_included_ligands_correctly(self): request = HttpRequest() request.method = 'POST' request.session = self.engine.SessionStore(None) request.session['pdb_id'] = '2HBQ' request.session['included_chains'] = ['A', 'B', 'C'] request.session['removed_chains'] = [] request.session['hetatms'] = [('PHQ', 'C', '1'), ('CF0', 'C', '5')] _dict = {'hetatms' : '0'} _qdict = QueryDict('', mutable=True) _qdict.update(_dict) request.POST = _qdict response = hetatm_setup(request) self.assertIn(['1', 'C'], request.session.get('included_hetatms'))
def merge_defaults(self): if self.use_defaults: data = QueryDict('', mutable=True) if self.data: data.update(self.data) initial = self.initial_data for key in initial: if key in data: continue value = initial[key] name = self.add_prefix(key) if value is not None: if isinstance(value, (list, tuple)): data.setlistdefault(name, value) else: data.setdefault(name, value) self.data = data
def __init__(self, *args, **kwargs): newPosts = QueryDict("", True) if len(args) > 0: posts = dict(args[0].items()) if posts["dlDate"] and posts["dlHour"] and posts["dlMin"]: posts["deadline"] = self.getDeadline(posts["dlDate"], posts["dlHour"], posts["dlMin"]) if posts["terms"]: posts["term"] = posts["terms"] posts["identifier"] = self.randStr(20) newPosts.update(posts) super(EventForm, self).__init__((newPosts)) else: super(EventForm, self).__init__(*args, **kwargs)
def read_raw_data(self, request): # convert the data into the correct format and add # it as POST variables. from django.http.request import QueryDict, MultiValueDict if not request.method in ['POST', 'PUT']: request._post, request._files = QueryDict('', encoding=request._encoding), MultiValueDict() else: # TODO multipart (files) not supported. q = QueryDict('', encoding=request._encoding).copy() d = self._raw_data_to_dict(request) for key in d.keys(): if isinstance(d[key], list): q.setlist(key, d.pop(key)) q.update(d) request.method = 'POST' request._post = q request._files = MultiValueDict()
def test_hetatm_setup_POST_redirects_to_source_setup(self): request = HttpRequest() request.method = 'POST' request.session = self.engine.SessionStore(None) request.session['pdb_id'] = '2HBQ' request.session['included_chains'] = ['A', 'B', 'C'] request.session['hetatms'] = [('PHQ', 'C', '1'), ('CF0', 'C', '5')] request.session['removed_chains'] = [] _dict = {'hetatms' : '0'} _qdict = QueryDict('', mutable=True) _qdict.update(_dict) request.POST = _qdict response = hetatm_setup(request) self.assertEqual(response.status_code, 302) self.assertEqual(response['location'], '/source')
def test_value_from_datadict(self): formset = formset_factory(ContactsForm) widget = widgets.ContactsWidget(attrs={'formset': formset}) data = { 'contacts-TOTAL_FORMS': '2', 'contacts-INITIAL_FORMS': '1', 'contacts-MAX_NUM_FORMS': '0', 'contacts-MAX_NUM_FORMS': '1000', 'contacts-0-name': 'Ringo', 'contacts-0-email': '*****@*****.**', 'contacts-0-tel': '555-555', 'contacts-1-name': '', 'contacts-1-email': '', 'contacts-1-tel': '' } q_dict = QueryDict('', mutable=True) q_dict.update(data) value = widget.value_from_datadict(q_dict, {}, 'contacts') assert isinstance(value, formset)
def test_ds_response_3(self): """ Testing that it works with get data from an advanced search """ get_dic = { 'search_name': 'wha%', 'search_pi': 'jame%', 'from_date_year': '2015', 'from_date_month': '11', 'from_date_day': '19', 'to_date_year': '2015', 'to_date_month': '11', 'to_date_day': '22', } response = self.client.get( '/experimentsearch/data_source/What is up/', get_dic ) from_get = QueryDict(mutable=True) from_get.update(get_dic) self.assertEqual(QueryDict(query_string=response.context['from_dic']), from_get) self.assertTemplateUsed(response, 'experimentsearch/datasource.html') expected_table = DataSourceTable(ds_table_set) actual_table = response.context['table'] self.check_tables_equal(actual_table, expected_table, DataSourceForTable)
def test_source_redirects_to_results(self): request = HttpRequest() request.method = 'POST' request.session = self.engine.SessionStore(None) request.session['pdb_id'] = '1SC1' request.session['included_chains'] = ['A', 'B'] request.session['removed_chains'] = ['A'] request.session['hetatms'] = [('PHQ', 'C', '1'), ('CF0', 'C', '5')] request.session['residue_list'] = [('125', 'A'), ('126', 'A')] _dict = {'residues' : '0'} _qdict = QueryDict('', mutable=True) _qdict.update(_dict) request.POST = _qdict response = source_setup(request) self.assertEqual(response.status_code, 302) self.assertEqual(response['location'], '/results')
def post(self, request, *args, **kwargs): from django.http.request import QueryDict form_class = self.get_form_class() # Recibe la peticion enviada por POST # y actualiza agregando los campos por defecto basados en la vista data = QueryDict.dict(request.POST) data.update(**self.get_default_fields()) qdict = QueryDict('', mutable=True) qdict.update(data) form = form_class(qdict) if form.is_valid(): return self.form_valid(form) else: return self.form_invalid(form)
def plugin_caller(specs, query): p = compile("(^.+?)_.*$") # Add '?' to prevent greedy matching unique_plugins = set(str(p.match(s).groups(0)[0]) for s in query.keys() if p.match(s)) plugin_funcs = JSCommand.get_functions() for p in unique_plugins: # print("plugin: ", p,plugins.base.plugin_funcs.keys()) if plugin_funcs.has_key(p): start=len(p+"_") params = {k[start:]:v for (k,v) in query.items() if k.startswith(p+"_") and len(k) > start} query_params = QueryDict('', mutable=True) query_params.update({k:v for (k,v) in query.items() if k.startswith(p+"_")}) params['query_params'] = query_params.urlencode() specs = plugin_funcs[p](specs, params) #print(plugin_funcs[p].__name__) #import pdb; pdb.set_trace() else: raise exceptions.PluginNotFoundError('Can\'t find plugin %s' %p) return specs
def get_data(self): if '@disable_auto_data' in self._data: return self._data if not hasattr(self, '_data_'): self._data_ = self._data if isinstance(self._data, MergeDict): data = QueryDict(None, mutable=True) for d in self._data.dicts: data._encoding = d._encoding data.update(d) self._data = data # Make data mutable elif not getattr(self._data, '_mutable', True): self._data_ = self._data.copy() # Make data mutable for name, field in self.fields.items(): initial_value = None prefixed_name = self.add_prefix(name) data_value = field.widget.value_from_datadict(self._data_, self.files, prefixed_name) if data_value is None: if not field.show_hidden_initial: initial_value = self.initial.get(name, field.initial) if callable(initial_value): initial_value = initial_value() else: initial_prefixed_name = self.add_initial_prefix(name) hidden_widget = field.hidden_widget() try: initial_value = field.to_python(hidden_widget.value_from_datadict( self.data, self.files, initial_prefixed_name)) except ValidationError: # Always assume data has changed if validation fails. self._changed_data.append(name) continue if callable(initial_value): initial_value = initial_value() if initial_value is not None: self._data_[prefixed_name] = initial_value return self._data_
def generate_link(search_param_parser, offset_prediction): """ Generate next/previous URL links Args: search_param_parser(SearchParamParser): Parsed Request Search Object offset_prediction: offset prediction number Returns: URL for next/previous links (string) """ query_temp = QueryDict(mutable=True) query_temp.update({'search': search_param_parser.search_string}) query_temp.update({'offset': offset_prediction}) query_temp.update({'limit': search_param_parser.limit}) # Limit stays the same [query_temp.update({'category': current_category}) for current_category in search_param_parser.categories] [query_temp.update({'agency': current_category}) for current_category in search_param_parser.agencies] [query_temp.update({'type': current_category}) for current_category in search_param_parser.listing_types] return '{!s}/api/listings/essearch/?{!s}'.format(search_param_parser.base_url, query_temp.urlencode())
def query_string_from_dict(qs_dict): qdict = QueryDict('').copy() qdict.update(qs_dict) return qdict.urlencode()
def __init__(self, *args, **kwargs): user = kwargs.pop('user') super(CreateJobForm, self).__init__(*args, **kwargs) # Request details fieldset branchList = [] for branch in user.branch.all(): branchList.append((branch.name, branch.name)) branchAmount = len(branchList) self.fields['branches'] = forms.ChoiceField( widget=forms.RadioSelect, choices=tuple(branchList), ) if branchAmount == 1: data = QueryDict('', mutable=True) data.update(self.data) data['branches'] = branchList[0][0] self.data = data self.fields['branches'].widget.attrs = {'disabled' : 'true', 'checked' : 'true'} self.fields['title'].widget.attrs = {'autofocus':'true', 'id':'job_title', 'placeholder':_('Request title')} self.fields['date'].required = False self.fields['start_time'] = forms.TimeField( widget=forms.TimeInput( attrs={'placeholder' : 'Format: 00:00'}, ), label=_('Start time'), ) self.fields['duration'] = forms.TimeField( widget=forms.TimeInput( attrs={'placeholder' : 'Format: 00:00'}, ), label=_('Duration'), ) self.fields['km'] = forms.DecimalField( min_value=0, initial=0, label=_('Distance to be covered (approximation)'), max_digits=4, ) # Job category fieldset self.fields['category'] = forms.ChoiceField( widget=forms.RadioSelect, choices=Job.CAT ) # self.fields['other'] = forms.CharField( # required=False, # widget=TextInput( # attrs={'placeholder':'Other'} #TODO disabled # ) # ) # Job timeline fieldset self.fields['frequency'] = forms.ChoiceField( widget=forms.RadioSelect, choices=Job.FREQ ) self.fields['dayrange'] = forms.MultipleChoiceField( required=False, widget=forms.CheckboxSelectMultiple, choices=((x,x) for x in range(1,32)) ) # Job visibility fieldset self.fields['visibility'] = forms.MultipleChoiceField( widget=forms.CheckboxSelectMultiple, choices=Job.JOB_VISIBILITY_TUPLE )
def format_filter(self, obj): qd = QueryDict(mutable=True) filter_fields = self.filter.keys() for field_name in filter_fields: qd.update({'[{}]'.format(field_name): self.lookup_attribute(obj, self.filter[field_name])}) return qd.urlencode(safe=['[', ']'])
def YATSSearch(request): def ValuesQuerySetToDict(vqs): return [item for item in vqs] tic = get_ticket_model().objects.select_related('type', 'state', 'assigned', 'priority', 'customer').all() data = json.loads(request.body) if 'extra_filter' in data: extra_filter = data['extra_filter'] del data['extra_filter'] else: extra_filter = None if 'days' in data: days = data['days'] del data['days'] else: days = None if 'exclude_own' in data: exclude_own = data['exclude_own'] del data['exclude_own'] else: exclude_own = False POST = QueryDict(mutable=True) POST.update(data) form = SearchForm(POST, include_list=settings.TICKET_SEARCH_FIELDS, is_stuff=request.user.is_staff, user=request.user, customer=request.organisation.id) form.is_valid() for err in form._errors: field = form.fields[err] # b = type(field) if err in ['c_user', 'assigned']: try: form.cleaned_data[err] = field.choices.queryset.get(username=data[err]).pk except: form.cleaned_data[err] = -1 else: try: form.cleaned_data[err] = field.choices.queryset.get(name=data[err]).pk except: form.cleaned_data[err] = -1 search_params, base_query = build_ticket_search(request, tic, {}, clean_search_values(form.cleaned_data)) if extra_filter: if extra_filter == '1': # days since closed base_query = base_query.filter(close_date__gte=datetime.date.today() - datetime.timedelta(days=days)).exclude(close_date=None) if extra_filter == '2': # days since created base_query = base_query.filter(c_date__gte=datetime.date.today() - datetime.timedelta(days=days)) if extra_filter == '3': # days since last changed base_query = base_query.filter(u_date__gte=datetime.date.today() - datetime.timedelta(days=days)) if extra_filter == '4': # days since last action base_query = base_query.filter(last_action_date__gte=datetime.date.today() - datetime.timedelta(days=days)) if extra_filter == '5': # days since falling due base_query = base_query.filter(deadline__lte=timezone.now() - datetime.timedelta(days=days)).filter(deadline__isnull=False) if exclude_own: base_query = base_query.exclude(assigned=request.user) seen = tickets_participants.objects.filter(user=request.user, ticket__in=base_query.values_list('id', flat=True)).values_list('ticket_id', 'seen') seen_elements = {} for see in seen: seen_elements[see[0]] = see[1] neededColumns = ['id', 'caption', 'c_date', 'type__name', 'state__name', 'assigned__username', 'deadline', 'closed', 'priority__color', 'customer__name', 'customer__hourly_rate', 'billing_estimated_time', 'close_date', 'last_action_date'] """ availableColumns = [] tickets = get_ticket_model() t = tickets() for field in t._meta.fields: if field.name in neededColumns: availableColumns.append(field.name) """ result = ValuesQuerySetToDict(base_query.values(*neededColumns)) for ele in result: ele['seen'] = 0 if ele['id'] in seen_elements: if seen_elements[ele['id']]: ele['seen'] = 2 else: ele['seen'] = 1 return result
def get_request_data(request): # simulate old request.REQUEST for backwards compatibility data = QueryDict(query_string=None, mutable=True) data.update(request.GET) data.update(request.POST) return data