def get_queryset(self): form = SearchForm(self.request.GET) if form.is_valid(): return File.objects.filter( name__icontains=form.cleaned_data['name']) else: return File.objects.all()
def search(request, term=None): form = search_term = result_list = results = None if request.POST: form = SearchForm(request.POST) if form.is_valid(): search_term = form.cleaned_data['terms'] if term is not None: # Note, we might need to do some cleanup here search_term = term if search_term is not None: # Get results result_list = BaseStop.search(search_term) paginator = Paginator(result_list, 25) page = request.GET.get('page', 1) try: results = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. results = paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. results = paginator.page(paginator.num_pages) if form is None: form = SearchForm() return render(request, 'stops/results.html', { 'results': results, 'term': search_term, 'form': form })
def search_form(request,queryset,Model): if request.method =="POST": form = SearchForm(request.POST) if form.is_valid(): search = str(form.cleaned_data['search']).lower() results = list() #Loop over object in queryset of model for object in queryset: model_dict = model_to_dict(object) print (model_dict) #Check if the searched string is included in one of the Object field """ for key in model_dict: print('Searching: ') print (model_dict[key]) """ if search in str(model_dict['name']): #Add the users id in a list print('I found d') results.append(object.id) break #Re-initialize the model queryset filtering by found objects.id queryset = Model.objects.filter(pk__in = (results)) else: form = SearchForm() queryset = Model.objects.all() return queryset
def search(request): """ On post, recieve a string and radius, geocode, and return a bunch of buddies within that radius """ # prevent access by non-organisations try: organisation = request.user.organisation.all()[0] except IndexError: return HttpResponseForbidden() form = SearchForm(request.POST or None) if form.is_valid(): buddies_in_range = [] # geocode address lat, lng = geocode(request.POST.get('location')) # to keep things super simple, pull out all buddies, then filter in # memory. obviously this will have to be fixed once there is a # non-trivial number of buddies in the db. and when we have more # than a day to work on this thing buddies = Buddy.objects.all() for buddy in buddies: buddy_lat, buddy_lng = float(buddy.location['latitude']), float(buddy.location['longitude']) radius = int(request.POST.get('radius')) dist = points2distance(((buddy_lng, 0, 0), (buddy_lat, 0, 0)),((lng, 0, 0), (lat, 0, 0))) if dist <= radius: buddies_in_range.append(buddy) else: buddies_in_range = None return render_to_response('buddies/search.html', { 'form': form, 'buddies_in_range': buddies_in_range, 'is_get': request.method == 'GET' }, context_instance=RequestContext(request))
def search_view(request, uid): form = SearchForm(request.GET) if form.is_valid(): ( query, count, results, facets, ) = do_search(uid, form.cleaned_data['query']) else: ( query, count, results, facets, ) = do_search(uid, '') sio = StringIO.StringIO() pprint.pprint(query, stream=sio, indent=4) context = { 'query': json.dumps(query, indent=4), 'count': count, 'results': results, 'facets': facets } return render(request, 'entitlements/search.html', context)
def index(request): if request.method == "POST": form = SearchForm(request.POST) if form.is_valid(): url=weather_url.format(request.POST['ciudad']) ciudad=request.POST['ciudad'] toDel = Weather.objects.filter(zipcode=ciudad) toDel.delete() response = requests.get(url) json_response = json.loads(response.text) w= Weather(temperature=k_to_c(json_response["main"]["temp"]),zipcode=ciudad, description=json_response["weather"][0]["description"], sunrise= datetime.utcfromtimestamp(json_response["sys"]["sunrise"]), sunset= datetime.utcfromtimestamp(json_response["sys"]["sunset"]),wind= json_response["wind"]["speed"]) w.save() #html="<html><body>%s y %s</body></html>"% (w.temperature, w.zipcode) context_dict = {} context_dict['temperature'] = k_to_c(json_response["main"]["temp"]) context_dict['zipcode'] = ciudad context_dict['description'] = json_response["weather"][0]["description"] context_dict['sunrise']= datetime.utcfromtimestamp(json_response["sys"]["sunrise"]) context_dict['sunset']= datetime.utcfromtimestamp(json_response["sys"]["sunset"]) context_dict['wind']= json_response["wind"]["speed"] return render(request, 'weather/weather.html', context_dict) else: w= Weather.objects.all() context_dict = {'city': w,'form':SearchForm()} return render(request, 'weather/index.html', context_dict)
def searchart(req): if req.method == "POST": form = SearchForm(req.POST) if form.is_valid(): form_data = form.cleaned_data keywords = form_data['keyword'] list = models.Article.objects.filter( title__contains=keywords).order_by("-publish_date") for article in list: strs = str(article.head_img) if 'static/uploads' in strs: article.head_img = '/' + str(article.head_img) objects, page_range = my_pagination(req, list) else: return HttpResponseRedirect('/') #列表页推荐标签 tag = show_tag(20) return render(req, 'search.html', { 'tag': keywords, 'list': objects, 'page_range': page_range, 'tags': tag }, context_instance=RequestContext(req))
def search(request): def make_tups(list, name='None'): tup = (('None', '%s' % name),) for item in list: tup = tup + ((item, item),) return tup poller_choices = make_tups(Poller.objects.all().values_list('name', flat=True).order_by('name'), 'Pollers') server_choices = make_tups(Server.objects.all().values_list('name', flat=True).order_by('name'), 'Servers') if request.method == 'POST': form = SearchForm(request.POST, poller_choices=poller_choices, server_choices=server_choices) if form.is_valid(): data = form.cleaned_data transfers = TransferLog.objects.all().order_by('-started') if data['server'] != 'None': transfers = transfers.filter(server__exact=data['server']).order_by('-started') if data['poller'] != 'None': transfers = transfers.filter(name__exact=data['poller']).order_by('-started') if data['status'] != 'None': transfers = transfers.filter(status__exact=data['status']).order_by('-started') if data['filename'] != '': transfers = transfers.filter(filename__icontains=data['filename']).order_by('-started') return render(request, 'dispatch_web/search.html', {'form': form, 'transfers': transfers}) else: form = SearchForm(poller_choices=poller_choices, server_choices=server_choices) return render(request, 'dispatch_web/search.html', {'form': form})
def search(request): did_post_pun = "" if request.method == "POST": form, did_post_pun = process_pun_form(request) else: form = PunForm() context_dict = {"new_pun_form": form, "search_form": SearchForm()} query_string = "" puns = Pun.objects.all() search_form = SearchForm(request.GET) if search_form.is_valid(): data = search_form.cleaned_data query_string = data["search"] puns = watson.filter(Pun, query_string) if puns is not None: puns = order_query_set_by_pun_score(puns) for pun in puns: pun.profile = UserProfile.objects.get(user=pun.owner) if request.user.is_authenticated(): puns = set_up_down_votes(request, puns) profile = UserProfile.objects.get(user=request.user) if not profile.show_nsfw: puns = [pun for pun in puns if pun.NSFW == False] context_dict["tags_list"] = get_all_tags_list() context_dict["query_string"] = query_string context_dict["puns"] = puns response = render_to_response("punny/search-results.html", context_dict, context_instance=RequestContext(request)) if did_post_pun is True: response.set_cookie("success", "pun posted!", max_age=3) elif did_post_pun is False: response.set_cookie("failed", "post failed", max_age=3) return response
def List(request): try: if CheckAccess(request,'23') != 'OK': return render_to_response("mtmc/notaccess/mtmc.html") except: return HttpResponseRedirect('/') if request.method == 'POST': formuser = UserForm(request.POST) if formuser.is_valid(): user = formuser.cleaned_data['user'] request.session['user_id'] = user formsearch = SearchForm(request.POST) if formsearch.is_valid(): search = formsearch.cleaned_data['search'] r = FindKey(search) if len(r) == 1: return HttpResponseRedirect('/mtmcedit/?eq_id=%s' % search) ### --- Сохранное занчение user_id --- try: user_id = request.session['user_id'] except: user_id = '' try: print_ok = request.GET['print'] response = HttpResponse(content_type='application/pdf') response['Content-Disposition'] = 'attachment; filename="list.pdf"' buff = StringIO() result = PrintForm(buff,user_id) response.write(result.getvalue()) buff.close() return response except: pass formmove = MoveForm(None) formsearch = SearchForm(None) formuser = UserForm(None) formuser.fields['user'].initial = user_id data = GetList(user_id) if len(data)!=0 and user_id != 'ALL': print_ok = True else: print_ok = False c = RequestContext(request,{'data':data,'formuser':formuser,'formsearch':formsearch,'formmove':formmove,'print_ok':print_ok}) c.update(csrf(request)) return render_to_response("mtmc/list.html",c)
def home(request): """ Manages our home page. If a POST request is received, then we're going to pull the search value out and attempt to filter for it. This can be a hash or a plaintext value. """ if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): data = HashModel.objects.all() search = request.POST.get("search_input") # search the hashval and plaintext fields result = data.filter(Q(hashval=search) | Q(plaintext=search)) return render_to_response('home.html', {'form':SearchForm(), 'results':result }, context_instance=RequestContext(request)) return render_to_response("home.html", {'form' : SearchForm(), 'results':HashModel.objects.all()[:50] }, context_instance=RequestContext(request))
def account_view(request): context = {} context['user'] = request.user # Search if request.method == 'POST': form = SearchForm(request.POST) if request.user.is_authenticated(): if form.is_valid(): search = Search.objects.create( url=form.cleaned_data['url'], title=form.cleaned_data['title'], owner=request.user) search.save() # redirect to proper search return redirect(reverse('search')) else: # return form errors return render_to_response('account.html', context, RequestContext(request)) else: # permissions should make this impossible return render_to_response('account.html', context, RequestContext(request)) context['search_form'] = SearchForm() # context['searches'] = Search.objects.filter(owner=request.user).all() context['searches'] = Search.objects.all() for search in Search.objects.all(): print search.created return render_to_response('account.html', context, RequestContext(request))
def test_search(request, code): invitation = check_invitation(code) if not invitation: messages.error(request, 'Your personal URL is incorrect, please reset your account or provide proper url') return redirect('index') results={} from forms import SearchForm if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): keywords = __to_keywords(form.cleaned_data['search']) for k in keywords: profiles = Profile.objects.filter(keywords=k) for p in profiles: count = results.get(p, 0) results[p]=count+1 if len(results)==0: messages.error(request, "Sorry, we couldn't find match for you. Try later.") else: form=SearchForm() return render_to_response('researchers/test_search.html', {'key':code, 'form':form, 'results':results, 'sorted':sorted(results.items(), key=lambda x: -x[1])}, context_instance=RequestContext(request))
def index(request): if request.method == 'POST': client_id = CLIENT_ID client_secret = CLIENT_SECRET r = requests.post('https://api.yelp.com/oauth2/token', data={'client_id': client_id, 'grant_type': 'password', 'client_secret': client_secret}) if not r.ok: form = SearchForm() messages.error(request, 'Authentication Failure.') return render(request, 'index.html', {'form': form}) r_data = r.json() token = r_data.get('access_token') token_type = r_data.get('token_type') form = SearchForm(request.POST) if form.is_valid(): city = form.data.get('city') payload = {'term': form.data.get('search'), 'location': city} header = {'Authorization': token_type + ' ' + token, 'Content-Type': 'application/x-www-form-urlencoded'} response = requests.get( 'https://api.yelp.com/v3/businesses/search', headers=header, params=payload) return render(request, 'results.html', {'data': response.json().get('businesses')}) else: form = SearchForm() return render(request, 'index.html', {'form': form})
def index_view(request): search_form = SearchForm() bugs = Bugs.objects if request.method == "GET": search_form = SearchForm(request.GET) if search_form.is_valid(): search = search_form.cleaned_data["search_text"] status = search_form.cleaned_data["status"] issue_types = search_form.cleaned_data["issue_types"] product = search_form.cleaned_data["product"] priority = search_form.cleaned_data["priority"] keyword = search_form.cleaned_data["keyword"] bugs = bugs.filter(short_desc__icontains=search) | \ bugs.filter(longdescs__thetext__icontains=search) bugs = bugs.distinct() if status != "": bugs = bugs.filter(bug_status__exact=status) if priority != "": bugs = bugs.filter(priority__exact=priority) if product: bugs = bugs.filter(product__name__exact=product) if keyword: bugs = bugs.filter(kws__id__exact=keyword) if issue_types == 1: bugs = bugs.exclude(bug_status__in=["CLOSED", "RESOLVED"]) bugs = bugs.order_by("bug_id").reverse() return render_to_response("index.html", { "bugs": bugs, "search_form": search_form, }, context_instance=RequestContext(request))
def check_in(request): form = SearchForm(request.GET or None) members = orchestras = None if form.is_valid(): term = form.cleaned_data.get('q') members = (Member.objects.filter(Q(first_name__istartswith=term) | Q(last_name__istartswith=term) | Q(pid__contains=term)) .select_related('orchestras') .order_by('first_name', 'last_name')) if len(members) == 1: member = members[0] return redirect('check_in_list', token=member.orchestras.all()[0].token, member_pk=member.pk) orchestras = Orchestra.objects.filter(Q(orchestra_name__icontains=term) | Q(short_name__icontains=term)) if len(orchestras) == 1: return redirect('check_in_list', token=orchestras[0].token) for member in members: member.orchestra_token = member.orchestras.all()[0].token return render(request, 'orkester/search.html', {'form': form, 'members': members, 'orchestras': orchestras})
def List(request): try: user = GetUserKod(request) except: return HttpResponseRedirect('/') ### --- Удаление файла --- if request.method == 'GET': try: delete_id = request.GET['delete_file'] DelFile(delete_id) except: pass ### --- Получение номера страницы --- try: page = int(request.GET.get('page',1)) request.session['page'] = page except: pass try: page = int(request.session['page']) except: page = 1 try: search = request.session['search'] except: search = '' if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): search = form.cleaned_data['search'] request.session['search'] = search data = ListFile(user,search) paginator = Paginator(data,50) try: data_page = paginator.page(page) except (EmptyPage, InvalidPage): data_page = paginator.page(paginator.num_pages) form = SearchForm(None) form.fields['search'].initial = search c = RequestContext(request,{'data':data_page,'form':form}) c.update(csrf(request)) return render_to_response("userfiles/list.html",c)
def search(request): if (request.method == 'POST'): form = SearchForm(request.POST) if (form.is_valid()): fields = form.cleaned_data query = "" if (fields['title'] != ''): query += "book=" + fields['title'] + "&" if (fields['author'] != ''): query += "author=" + fields['author'] + "&" if (fields['series'] != ''): query += "series=" + fields['series'] + "&" if (fields['editor'] != ''): query += "editor=" + fields['editor'] return redirect('/bookworm/search?' + query) else: book = request.GET.get('book', '') author = request.GET.get('author', '') series = request.GET.get('series', '') editor = request.GET.get('editor', '') if (book == '' and author == '' and series == '' and editor == ''): # Query is empty return render(request, 'books/form.html', {'form': SearchForm()}) books = Book.objects.all() fields = {} if (book != ''): books = books.filter(title__contains=book) fields['book'] = book if (author != ''): books = books.filter(author__name__contains=author) fields['author'] = author if (editor != ''): books = books.filter(editor__name__contains=editor) fields['editor'] = editor if (series != ''): parts = Part.objects.filter(series__name__contains=series) fields['series'] = series found = [] for book in books: for part in parts: if (book == part.book): found += [book] else: found = [book for book in books] print "Found in database:", found if (found == []): found = searchInApi(fields) result = buildResult(found, request.user) query = "" for field in request.GET: query += field + "=" + request.GET[field] + "&" return render(request, 'books/queryResult.html', { 'result': result, 'next': '/bookworm/search?' + query })
def test_valid_data(self): # valid data is at least 1 input is given form = SearchForm({ 'dept_name' : 'Admin' }) self.assertTrue(form.is_valid())
def search(request): if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): return HttpResponse(stream_response( request.POST['url'], request.POST['depth'], request.POST['search']), mimetype='text/html')
def search(request): """ Поиск пациентов """ patients_qs = Patient.objects.all() form = SearchForm(request.GET) special_cure_text = '' header = u'Все' if len(request.GET) == 0: # Если поиск не запускали, то и не надо показывать всех пациентов return render_to_response('search.html', {'form': form, 'have_search_result': False}, context_instance=RequestContext(request)) if form.is_valid(): full_name = form.cleaned_data.get('full_name') if full_name: patients_qs = patients_qs.filter(all_full_names__icontains=full_name) type_residence = form.cleaned_data.get('type_residence') if type_residence: patients_qs = patients_qs.filter(type_residence=type_residence) social_status = form.cleaned_data.get('social_status') if social_status: patients_qs = patients_qs.filter(social_status=social_status) birthday = form.cleaned_data.get('birthday') if birthday: patients_qs = patients_qs.filter(birthday=birthday) death = form.cleaned_data.get('death') if death: patients_qs = patients_qs.filter(death=death) mo_added = form.cleaned_data.get('mo_added') if mo_added: patients_qs = patients_qs.filter(visit__is_add=True, visit__mo=mo_added) special_cure = form.cleaned_data.get('special_cure') if special_cure: if special_cure in HEADER_SEARCH: header = HEADER_SEARCH[special_cure] patients_qs = patients_qs.filter(special_cure=special_cure) diagnosis = form.cleaned_data.get('diagnosis') if diagnosis: q_st = Q(diagnosis__code__contains=diagnosis) | \ Q(diagnosis__name__contains=diagnosis) with_diagnosis = patients_qs.filter(diagnosis__code__contains=diagnosis) patients_qs = patients_qs.filter(pk__in=with_diagnosis) patients_qs = patients_qs.values('pk', 'all_full_names', 'birthday', 'diagnosis_text_code', 'name_allocate_mo', 'gender') response = {'patients': patients_qs, 'count': patients_qs.count(), 'special_cure_text': special_cure_text, 'form': form, 'header': header, 'have_search_result': True} return render_to_response('search.html', response, context_instance=RequestContext(request))
def home(request, *arg): if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): pass else: form = SearchForm() c = RequestContext(request, {'form': form}) return render_to_response('home.html', c)
def call_list_view(request): def calls_duration(calls): """ IN: Queryset :rtype : dict of {sum calls min:, sum calls sec:, number of calls:} """ c_d = 0 for call in calls: c_d += call.billsec return {'min': c_d // 60, 'sec': c_d % 60, 'count': len(calls)} page = request.GET.get('page') if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): request.session['search_form'] = form.cleaned_data request.session['call_list'] = filter_from_form(form) page = 1 else: if request.GET == {} and request.POST == {}: try: request.session.pop('search_form') request.session.pop('call_list') except KeyError: pass if 'search_form' in request.session: form = SearchForm(request.session['search_form']) else: form = SearchForm() if not 'order_by' in request.session: request.session['order_by'] = '-calldate' if 'order' in request.GET: if request.GET['order'] == '-calldate' or request.GET['order'] == 'calldate': request.session['order_by'] = request.GET['order'] if not 'call_list' in request.session: request.session['call_list'] = Cdr.objects.using('asterisk_db').filter(calldate__gte=datetime.date.today()) paginator = Paginator(request.session['call_list'].order_by(request.session['order_by']), 25) # 25 calls per page try: p_call_list = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. p_call_list = paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. p_call_list = paginator.page(paginator.num_pages) context = {'call_list': p_call_list, 'total_calls_duration': calls_duration(request.session['call_list']), 'page_calls_duration': calls_duration(p_call_list), 'form': form, 'module': 'call_list', 'saved_form': request.session, 'order_by': request.session['order_by'], } return render(request, 'ast_rec/call_list.html', context)
def code(request): form = SearchForm(request.GET) if form.is_valid(): result = form.search() return { 'criteries': criterion.CHOICE, 'result': result, 'critery': form.get_critery(), 'alters': form.get_alters() }
def post(self, request): form = SearchForm(request.POST) if form.is_valid(): query = form.cleaned_data['query'] tweets = Tweet.objects.filter(text__icontains=query) context = Context({"query": query, "tweets": tweets}) return_str = render_to_string('partials/_tweet_search.html', context) return HttpResponse(json.dumps(return_str), content_type="application/json") else: HttpResponseRedirect("/search")
def index(request): if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): query = form.cleaned_data['query'] return HttpResponseRedirect(reverse('search_app:search_results', args=(query,))) return render(request, 'search_app/index.html', {'form': form}) elif request.method == 'GET': form = SearchForm() return render(request, 'search_app/index.html', {'form': form})
def search_results(request): if request.method == 'GET': form = SearchForm(request.GET) if form.is_valid(): results = doSearch(form.cleaned_data['query']) return { 'query': form.cleaned_data['query'], 'results': results, } return {}
def author_search(request): if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): query_list = [] authname = form.cleaned_data['query'] author_list = [{'name': u'Evimaria Terzi', 'id': '1143572'}] author_list += sql.search_for_author(authname) return render(request, 'search/author_results.html', {"returned_list":author_list, "query_list":[authname]}) return HttpResponseRedirect('/')
def ItTask(request): if CheckAccess(request,'3') != 'OK': return render_to_response("ithelpdesk/notaccess/task.html") ### --- Сохранение закладки ---- request.session['bookmark'] = 'ittask' ### --- Получение номера страницы --- try: page = request.GET['page'] request.session['page'] = page except: pass try: page = request.session['page'] except: page = '1' if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): search = form.cleaned_data['search'] request.session['search'] = search else: form = SearchForm() try: search = request.session['search'] except: search = '' form.fields['search'].initial = search data = GetItTaskList(search) paginator = Paginator(data,50) try: data_page = paginator.page(page) except (EmptyPage, InvalidPage): data_page = paginator.page(paginator.num_pages) c = RequestContext(request,{'form':form,'data':data_page}) c.update(csrf(request)) return render_to_response("ithelpdesk/task.html",c)
def List(request): try: if CheckAccess(request,'7') != 'OK': return render_to_response("notaccess.html") except: return HttpResponseRedirect('/') ### --- Получение номера страницы --- try: page = int(request.GET.get('page',1)) request.session['page'] = page except: pass try: page = int(request.session['page']) except: page = 1 if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): search = form.cleaned_data['search'] request.session['search'] = search else: form = SearchForm() try: search = request.session['search'] except: search = '' form.fields['search'].initial = search data = GetANewTaskTrip(search) paginator = Paginator(data,50) try: data_page = paginator.page(page) except (EmptyPage, InvalidPage): data_page = paginator.page(paginator.num_pages) c = RequestContext(request,{'form':form,'data':data_page}) c.update(csrf(request)) return render_to_response("auto/list.html",c)
def index(request): if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): query = form.cleaned_data['query'] return HttpResponseRedirect( reverse('search_app:search_results', args=(query, ))) return render(request, 'search_app/index.html', {'form': form}) elif request.method == 'GET': form = SearchForm() return render(request, 'search_app/index.html', {'form': form})
def search(request): limit = 1000 order = 'position' context = {} form = SearchForm() if request.method == 'GET': form = SearchForm(request.GET) if form.is_valid(): seq = form.cleaned_data['seq'] chromosome = form.cleaned_data['chromosome'] if seq: seqs = [] if chromosome: Sequence = get_model('hg19', 'Sequence{}'.format(chromosome)) chromosome_to_search = [(Sequence, chromosome)] else: chromosome_to_search = [] for m in models.get_models(): if m.__name__.startswith('Sequence'): chromosome_to_search.append((m, m.__name__.replace('Sequence', ''))) initial_time = time.time() if 'complex_search' in request.GET: for S, c in chromosome_to_search: q = S.objects.search_between(S, seq) for s in q: #start count from 1 position = s[2]+s[1].index(seq)+1 seqs.append({'position': position, 'seq': s[1], 'chromosome': c}) elif 'search_postgres' in request.GET: for S, c in chromosome_to_search: q = S.objects.filter(seq__contains=seq).order_by(order)[:limit] for s in q: #start count from 1 position = s.position + s.seq.index(seq) + 1 seqs.append({'position': position, 'seq': s.seq, 'chromosome': c}) elif 'search_postbis' in request.GET: if chromosome: cs = ChromosomeSequence.objects.filter(name=chromosome) else: cs = ChromosomeSequence.objects.all() for c in cs: pos = ChromosomeSequence.objects.find_all_positions(c, seq) for p in pos: seqs.append({'position': p, 'seq': c.get_substring(p-50, 100+len(seq)), 'chromosome': c.name}) final_time = time.time() context['search_time'] = final_time - initial_time table = SearchResultsTable(seqs, query=seq) context['table'] = table context['seqs'] = seqs context['form'] = form return render(request, 'hg19/search.html', context)
def search_form_post(request): # функция получения POST запроса на поиск в базе и вывод результата data_from_form = SearchForm(request.POST) # получение POST запроса if data_from_form.is_valid(): # валидация данных data = data_from_form.cleaned_data result = search_in_db(data) # вызов функции поиска в базе context = {'context': result} # словарь для формирования html страницы с ответом if len(result) > 0: # проверка, нашел ли что-то поиск return render(request, 'result_table.html', context) # если нашел - рендерим ответный html else: return HttpResponse('No data found') # если пустой результат поиска - выводим сообщение data = data_from_form.errors return HttpResponse('Wrong input: {0}'.format(data))
def vksearch(request): user = request.user context = { 'show_login': False, 'redirect_querystring': 'next=%s' % reverse('vksearch') } if not user.is_authenticated(): context['show_login'] = True return render(request, 'vksearch/vksearch.html', context) try: usa = user.social_auth.get() except user.social_auth.model.DoesNotExist: context['show_login'] = True return render(request, 'vksearch/vksearch.html', context) else: vk_api = vkontakte.API(token=usa.extra_data['access_token']) if request.GET: form = SearchForm(request.GET) else: form = SearchForm() context['form'] = form query = None if form.is_valid(): query = form.cleaned_data['query'] try: audio_list = get_vk_audio(vk_api, query=query) except vkontakte.VKError: context['show_login'] = True return render(request, 'vksearch/vksearch.html', context) if not audio_list: return render(request, 'vksearch/vksearch.htm', context) paginator = Paginator(audio_list, 25) page = request.GET.get('p') try: audio_list = paginator.page(page) except PageNotAnInteger: audio_list = paginator.page(1) except EmptyPage: audio_list = paginator.page(paginator.num_pages) context['content'] = audio_list return render(request, 'vksearch/vksearch.html', context)
def search(request): if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): name = form.cleaned_data['name'] #user = User.objects.filter(user=name) return HttpResponseRedirect('/search/search_detail/') else: form = SearchForm() return render_to_response('search/search.html', {'form': form, 'searchpage': True}, context_instance=RequestContext(request))
def search(request): ''' return the needed results ''' form = SearchForm(request.GET) if form.is_valid(): process_func = _extract_process_type(form.cleaned_data['process']) return process_func(request, form) logger.error(form.errors) context = request.GET.dict() context.update(title='DAPOS', form=form) return render(request, 'home.html', context)
def search_view(request, uid): form = SearchForm(request.GET) if form.is_valid(): (query, count, results, facets,) = do_search(uid, form.cleaned_data['query']) else: (query, count, results, facets,) = do_search(uid, '') sio = StringIO.StringIO() pprint.pprint(query, stream=sio, indent=4) context = {'query': json.dumps(query, indent=4), 'count': count, 'results': results, 'facets': facets} return render(request, 'entitlements/search.html', context)
def info_list(request): user = request.user menger = Menger.objects.get(user=user) page = request.GET.get('page') page_items = 10 form = SearchForm() if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): keyword = form.data['keyword'] page = form.data['current_page'] if menger.insurance == 1: obj = Account_insurer elif menger.financing == 1: obj = Account_financing lists = obj.objects.filter( Q(shipname__contains=keyword) | Q(number__number__contains=keyword)) contacts_tmp = list(set(lists)) paginator = Paginator(contacts_tmp, page_items) # Show 25 contacts per page try: contacts = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. contacts = paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. contacts = paginator.page(paginator.num_pages) return render(request, 'info_list.html',\ {'form':form, 'contacts': contacts, 'user':user,'menger_insurance':menger.insurance,'menger_financing':menger.financing}) else: lists = Account_insurer.objects.all() paginator = Paginator(lists, page_items) # Show 25 contacts per page try: contacts = paginator.page(page) except PageNotAnInteger: # If page is not an integer, deliver first page. contacts = paginator.page(1) except EmptyPage: # If page is out of range (e.g. 9999), deliver last page of results. contacts = paginator.page(paginator.num_pages) return render(request, 'info_list.html',\ {'form':form, 'contacts': contacts, 'user':user})
def index(request): query = request.GET.get("query") if query: search_form = SearchForm({"query": query}) context = {"search_form": search_form} if search_form.is_valid(): cleaned_query, query_postings = search_form.get_query_info() context["query"] = query results = get_search_results(cleaned_query, query_postings) context["page_results"], context["page_range"] = get_page_results( results, request.GET.get("page", '1')) else: context = {"search_form": SearchForm()} return render(request, "index.html", context)
def ListTmc(request): ### --- Получение номера страницы --- try: page = int(request.GET.get('page', 1)) request.session['page'] = page except: pass try: page = int(request.session['page']) except: page = 1 try: search = request.session['search'] status = request.session['status'] group = request.session['group'] except: search = '' status = '' group = '' if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): search = form.cleaned_data['search'] status = form.cleaned_data['status'] group = form.cleaned_data['group'] request.session['search'] = search request.session['status'] = status request.session['group'] = group data = GetTmcList(search, group, status) form = SearchForm(None) form.fields['search'].initial = search form.fields['status'].initial = status form.fields['group'].initial = group paginator = Paginator(data, 50) try: data_page = paginator.page(page) except (EmptyPage, InvalidPage): data_page = paginator.page(paginator.num_pages) c = RequestContext(request, {'form': form, 'data': data_page}) c.update(csrf(request)) return render_to_response("tmc/tmc.html", c)
def search(request): if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): # gather user input book_code = request.POST['book_code'] chapter = request.POST['chapter'] mode = request.POST['mode'] question_name = request.POST['question_name'] question_name_exclude = request.POST['question_name_exclude'] question_field = request.POST['question_field'] # option to select "OR" relationship instead of the default "AND" relationship answer_bool = request.POST.get('answer_bool', False) answer_field = request.POST['answer_field'] # option to select "OR" relationship instead of the default "AND" relationship solution_bool = request.POST.get('solution_bool', False) solution_field = request.POST['solution_field'] # process book codes book_code = book_code.replace(" ", "") book_code_list = book_code.split(",") book_obj_list = [] # validate book codes for b in book_code_list: try: book_obj = Textbooks.objects.get(code=b) book_obj_list.append(book_obj) except Textbooks.DoesNotExist: return HttpResponse('Invalid book code') # construct query questions = view_query.query(book_obj_list, chapter, mode, question_name, question_name_exclude, question_field, answer_bool, answer_field, solution_bool, solution_field) # execute query string questions_eval = eval(questions) question = [q.code for q in questions_eval] count = len(question) return render( request, 'question_list.html', { 'count': count, 'book': book_code, 'question': question, 'query_string': questions }) else: form = SearchForm() return render(request, 'search_form.html', {'form': form})
def search_for_results(request): # import pdb; pdb.set_trace() if request.method == "POST": form = SearchForm(request.POST) if form.is_valid(): s = SearchEngine() res = s.search_text(form.cleaned_data['text']) pages = [] for url in res: pages.append(Page.objects.get(url=url)) f = SearchForm() return render(request, 'search/show_results.html', { 'pages': pages, 'form': f }) return HttpResponseRedirect(reverse('index'))
def results(request): search_form = SearchForm(request.GET) if not search_form.is_valid(): primers_list = Primer.objects.all() query_string = "" else: query_string = search_form.cleaned_data["query"] try: primers_list = Primer.objects.filter(name__icontains=query_string) except Primer.DoesNotExist: primers_list = [] return render_to_response('results.html', { 'query': query_string, 'primers_list': primers_list })
def search(request): if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): keyword = form.cleaned_data['keyword'] fornecedores = search_companies(keyword) return render(request, 'index.html', { 'form': form, 'fornecedores': fornecedores, }) else: form = SearchForm(auto_id=False) return render(request, 'index.html', { 'form': form, })
def query_based_search_view(request): user = check_validation(request) if user: if request.method == "GET": search_form = SearchForm(request.GET) if search_form.is_valid(): print 'valid search' username_query = search_form.cleaned_data.get('search_query') print username_query user_with_query = User.objects.filter(username=username_query).first(); posts = Post.objects.filter(user=user_with_query) return render(request, 'feed.html', {'posts': posts}) else: return redirect('/feed/') else: return redirect('/login/')
def results(request): if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): query_list = [] query = form.cleaned_data['query'] # print query # print query_list = query.split(';') # CHANGE TO STEMMED WORDS stemmed_query_list = [] stemmed_bigram_list = [] for x in query_list: if ' ' in x: bigram_break = x.split() for y in bigram_break: if y not in stop: stemmed_query_list.append(stem(y)) i = 0 while i < len(bigram_break)-1: if bigram_break[i] not in stop and bigram_break[i+1] not in stop: stemmed_bigram_list.append(stem(bigram_break[i])+'$'+stem(bigram_break[i+1])) i+=1 else: if x == '': pass else: stemmed_query_list.append(stem(x)) # COMBINE BIGRAMS AND STEMMED KEYWORDS final_query_list = stemmed_bigram_list + stemmed_query_list if len(stemmed_bigram_list) == 0: stemmed_bigram_list = [''] keyword_author_list = [{'score': 'a zillion', 'name': u'Evimaria Terzi', 'id': '1143572'}] bigram_author_list = [{'score': 'a zillion', 'name': u'Evimaria Terzi', 'id': '1143572'}] keyword_author_list += sql.search_for_keywords(stemmed_query_list) bigram_author_list += sql.search_for_bigrams(stemmed_bigram_list) #print author_list[0] # Search the database of people on query_list # Assemble best 5 people from each group return render(request, 'search/results.html', {"keyword_author_list":keyword_author_list, "bigram_author_list":bigram_author_list, "query_list":final_query_list}) return HttpResponseRedirect('/')
def query_based_search_view(request): user = check_validation(request) if user: if request.method == "POST": searchForm = SearchForm(request.POST) #checking whether searchform is valid or not if searchForm.is_valid(): print 'valid' username_query = searchForm.cleaned_data.get('searchquery') user_with_query = UserModel.objects.filter( username=username_query).first() posts = PostModel.objects.filter(user=user_with_query) return render(request, 'feed.html', {'posts': posts}) else: return redirect('/feed/') else: return redirect('/login/')
def search(request): if request.method == 'POST': form = SearchForm(request.POST) if form.is_valid(): search = form.cleaned_data['search'] showas = form.cleaned_data['showas'] if search: samples = mwinfo.objects.filter( Q(sha256__icontains=search) | Q(file_name__icontains=search) | Q(avlabel__icontains=search)).order_by('avlabel') else: samples = mwinfo.objects.order_by('sha256') context = {'samples': samples, 'search': search, 'showas': showas} return render(request, 'list.html', context) samples = mwinfo.objects.order_by('sha256') context = {'samples': samples, 'search': "", 'showas': "Samples"} return render(request, 'list.html', context)
def search_form_post( request ): # функция получения POST запроса на поиск в базе и вывод результата data_from_form = SearchForm(request.POST) # получение POST запроса if data_from_form.is_valid(): # валидация данных data = data_from_form.cleaned_data result = search_in_db(data) # вызов функции поиска в базе context = { 'context': result } # словарь для формирования html страницы с ответом if len(result) > 0: # проверка, нашел ли что-то поиск return render(request, 'result_table.html', context) # если нашел - рендерим ответный html else: return HttpResponse( 'No data found' ) # если пустой результат поиска - выводим сообщение data = data_from_form.errors return HttpResponse('Wrong input: {0}'.format(data))
def search_view(request): # check whether used is logged in user = check_validation(request) if user: if request.method == "POST": form = SearchForm(request.POST) # checking for valid form if form.is_valid(): username = form.cleaned_data['username'] x = UserModel.objects.filter(username=username) posts = PostModel.objects.filter( user=x).order_by('-created_on') if posts: return render(request, 'user.html', {'posts': posts}) else: form = SearchForm() # redirecting to feeds return render(request, 'search.html', {'form': form})
def post(self, request): form = SearchForm(request.POST) if form.is_valid(): # Little bit of cheating, ideally the html would handle this # but, I felt like building the webapp in django... # alternatively, I could just reach over and build this. start = form.cleaned_data['start'].isoformat() end = form.cleaned_data['end'].isoformat() # POST the query and return the pk, so we can look it up later r = requests.post('http://localhost:9000/api/query/', data={ 'start_date': start, 'end_date': end }) result = Result.objects.create(key=r.json()["pk"]) result.save() # To the results! return HttpResponseRedirect("/{0}/".format(r.json()["pk"])) else: return render(request, 'index.html', {'form': form})
def archive(request, key='all'): tasks = [] texts = [] if key == 'all': tasks = Task.objects.all() texts = Text.objects.all() elif key == 'video_lessons': tasks = Task.objects.filter(private=False).all() elif key == 'video_private': tasks = Task.objects.filter(private=True).all() elif key == 'text_lessons': texts = Text.objects.all() if request.method == 'POST': search_form = SearchForm(request.POST) if search_form.is_valid(): cd = search_form.cleaned_data tasks = Task.objects.filter(keyword__icontains=cd['keyword']) else: search_form = SearchForm() context = {'tasks': tasks, 'texts': texts, 'search_form': search_form} return render(request, 'archive.html', context)
def index(request): if request.method == 'POST': if FamilySearchDownload.objects.filter( filename=request.POST["filename"]).exists(): instance = FamilySearchDownload.objects.filter( filename=request.POST["filename"])[0] else: instance = SearchForm(request.POST) if instance.is_valid(): instance = instance.save() downloader = searcher.Downloader(instance) downloader.start() else: return render_to_response( "search.html", {"form": SearchForm()}, context_instance=RequestContext(request)) return redirect("Results", name=instance.filename) else: form = SearchForm() return render_to_response("search.html", {"form": form}, context_instance=RequestContext(request))
def indexes_search(request): form = SearchForm() if 'q' in request.GET: form = SearchForm(request.GET) if form.is_valid(): cd = form.cleaned_data results = SearchQuerySet().models(Indexes).filter( content=cd['q']).load_all() for i in results: print dir(i.objects) total_results = results.count() else: cd = {} results = [] total_results = [] return render(request, 'search.html', { 'form': form, 'cd': cd, 'results': results, 'total_results': total_results })
def home(request): #This code just moves the json to sqllite. Only should be called once for obvious reasons. # json_data=open('Home/IslandRentals.json') # data = json.load(json_data) # pprint(data) # json_data.close() # for prop in data["property"]: # try: # new_prop = Property() # new_prop.address = prop['address'] # new_prop.price = prop["price"] # size = Size(num_bedrooms=prop["size"]["num_bedrooms"],num_bathrooms=prop["size"]["num_bathrooms"],sq_ft=prop["size"]["sq_ft"],lot_sq_ft=prop["size"]["lot_sq_ft"]) # size.save() # new_prop.size = size # new_prop.proximity_to_volcanoe = prop["proximity_to_volcanoe"] # new_prop.school_rating = prop["school_rating"] # new_prop.distance_to_bar = prop["distance_to_bar"] # new_prop.image = prop["image"] # new_prop.home_type = prop["home_type"] # new_prop.distance_to_public_transit = prop["distance_to_public_transit"] # new_prop.save() # except: # print("Except") if request.method == 'POST': # create a form instance and populate it with data from the request: form = SearchForm(request.POST) # check whether it's valid: if form.is_valid(): # process the data in form.cleaned_data as required # ... # redirect to a new URL: price = form.cleaned_data['max_price'] properties = Property.objects.filter(price__lte=price)#less than or equal return render(request, 'home.html', {'form': form,'data':properties}) # if a GET (or any other method) we'll create a blank form else: form = SearchForm()#just make a new form properties = Property.objects.all() return render(request, 'home.html', {'form': form,'data':properties})