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 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 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 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})
