def search_by_key_words(request):
needed_posts = []
posts = BlogPost.objects.all()
search_form = SearchForm(request.POST)
if search_form.is_valid():
search_form.save()
d = search_form.cleaned_data
key_words = d['keywords']
key_words = key_words.split()
for key_word in key_words:
for post in posts:
if key_word in post.title or key_word in post.article:
needed_posts.append(post)
return render_to_response('post/posts.html', {
'posts': needed_posts,
'form': search_form
},
context_instance=RequestContext(request))
else:
categories = BlogPostCategory.objects.all()
new_posts = BlogPost.objects.all()[:2]
return render_to_response('base.html', {
'categories': categories,
'new_posts': new_posts,
'form': search_form
},
context_instance=RequestContext(request))
def post_search(request):
'''
搜索
:param request:
:return:
'''
form = SearchForm()
query = None
results = []
if 'query' in request.GET:
form = SearchForm(request.GET)
if form.is_valid():
query = form.cleaned_data['query']
# 设置搜索权重
search_vector = SearchVector('title', weight='A') + SearchVector(
'body', weight='B')
search_query = SearchQuery(query)
results = Post.objects.annotate(
search=search_vector,
rank=SearchRank(
search_vector,
search_query)).filter(rank__gte=0.3).order_by('-rank')
return render(request, 'blog/post/search.html', {
'query': query,
'form': form,
'results': results
})
def post_search(request):
form = SearchForm()
query = None
results = []
if 'query' in request.GET:
form = SearchForm(request.GET)
if form.is_valid():
query = form.cleaned_data['query']
search_vector = SearchVector('title', weight='A') + SearchVector(
'body', weight='B')
search_query = SearchQuery(query)
# results = Post.objects.annotate(
# rank=SearchRank(search_vector, search_query)
# ).filter(rank__gte=0.3).order_by('-rank')
results = Post.objects.annotate(similarity=TrigramSimilarity(
'title',
query), ).filter(similarity__gt=0.1).order_by('-similarity')
return render(request, 'blog/post/search.html', {
'form': form,
'query': query,
'results': results
})
def post_search(request):
form = SearchForm(request.GET or None)
query = None
posts = None
page_obj = None
paginator = None
if form.is_valid():
query = form.cleaned_data['query']
search_vector = SearchVector('title', weight='A') + SearchVector('body', weight='B')
search_query = SearchQuery(query)
posts = Post.published.annotate(rank=SearchRank(search_vector, search_query)).filter(
rank__gte=0.3).order_by('-rank')
paginator = Paginator(posts, settings.POSTS_PER_PAGE)
page = request.GET.get('page', 1)
try:
posts = paginator.page(page)
except PageNotAnInteger:
posts = paginator.page(1)
except EmptyPage:
posts = paginator.page(paginator.num_pages)
page_obj = pager.Page(posts.number, paginator.num_pages)
return render(request, 'blog/post/list.html', {
'query': query,
'paginator': paginator,
'posts': posts,
'page_obj': page_obj,
})
def drafts(page=1, sort='-created_at'):
''' Lists of posts in admin view that are not published, paginated and sortable.'''
form = SearchForm(request.form)
posts = Post.objects(published=False).order_by(sort).paginate(page, per_page=6)
if request.method == 'POST' and form.validate_on_submit():
redirect(url_for('posts.drafts', page=page))
return render_template("/admin/list.html",
posts=posts,
form=form,
cur_endpoint=request.endpoint)
def post_search(request):
form = SearchForm()
if 'query' in request.GET:
form = SearchForm(request.GET)
if form.is_valid():
cd = form.cleaned_data
results = SearchQuerySet.models(Post).filter(content=cd['query']).load_all()
# count total results
total_results = results.count()
return render(request, 'blog/post/search.html',
{'form': form, 'cd': cd, 'results': results, 'total_results': total_results})
def drafts(page=1, sort='-created_at'):
''' Lists of posts in admin view that are not published, paginated and sortable.'''
form = SearchForm(request.form)
posts = Post.objects(published=False).order_by(sort).paginate(page,
per_page=6)
if request.method == 'POST' and form.validate_on_submit():
redirect(url_for('posts.drafts', page=page))
return render_template("/admin/list.html",
posts=posts,
form=form,
cur_endpoint=request.endpoint)
def get_queryset(self):
from django.db.models import Q
if self.request.method == 'GET':
form = SearchForm(self.request.GET)
if form.is_valid():
query = form.cleaned_data['query']
words = query.split(' ')
qobjects = [Q(body__icontains=w) | Q(title__icontains=w) for w in words]
condition = reduce(lambda x,y: x & y, qobjects)
results = BlogPost.objects.filter(condition)
return results
return BlogPost.objects.none()
def search(request):
if request.method == "POST":
form = SearchForm(request.POST)
if form.is_valid():
query = form.cleaned_data['query']
post_list = Post.objects.filter(Q(name__icontains=query) |
Q(post_text__icontains=query) |
Q(author__name__icontains=query) |
Q(author__description__icontains=query))
news_list = News.objects.filter(Q(headline__icontains=query) |
Q(news_text__icontains=query))
print('abc')
return render(request, "search_list.html", {'post_list': post_list,
'news_list': news_list })
def search():
search = SearchForm()
if search.validate_on_submit():
# reference for how to input the data into the like statement
# accessed on 15/02/2021
# https://stackoverflow.com/questions/3325467/sqlalchemy-equivalent-to-sql-like-statement
query = "%{}%".format(search.query.data)
# refernce for filtering multiple columns
# accessed on 15/02/2021
# https://stackoverflow.com/questions/3332991/sqlalchemy-filter-multiple-columns
posts = Post.query.filter(db.or_(Post.title.like(query), Post.content.like(query)))
return render_template('search.html', posts=posts, search=search)
else:
flash("I am afraid your search failed as it must contain letters or numbers without trailing spaces. Please try again.")
return redirect(f'/allposts')
def post(post_id):
search = SearchForm()
post = Post.query.get_or_404(post_id)
paragraphs = post.content.split("#")
comments = Comment.query.filter(Comment.post_id == post.id)
form = CommentForm()
return render_template('post.html', title=post.title, post=post, comments=comments, form=form, search=search, paragraphs=paragraphs)
def subscriber_login_page(request):
if request.user.is_authenticated:
return redirect('subscriber_logout_page')
searchform = SearchForm()
form = SubscriberLoginForm(request.POST or None)
posts = Post.objects.get_published()[0:6]
context = {
'posts': posts,
'page_title': 'Login',
'form': form,
'search': searchform,
'pages': Page.objects.get_published(),
}
if form.is_valid():
username = form.cleaned_data["UserName"]
password = form.cleaned_data["PassWord"]
user = authenticate(request, username=username, password=password)
if user is not None:
login(request, user)
return redirect('list')
else:
context['error'] = 'Username and Password Doesn\'t match!!!'
context['form'] = SubscriberLoginForm()
context.update(common)
return render(request, 'auth.html', context)
def subscriber_register_page(request):
if request.user.is_authenticated:
return redirect('subscriber_logout_page')
form = RegisterForm(request.POST or None)
searchform = SearchForm()
posts = Post.objects.get_published()[0:6]
context = {
'form': form,
'page_title': 'Register',
'posts': posts,
'search': searchform,
'pages': Page.objects.get_published(),
}
if form.is_valid():
username = form.cleaned_data["UserName"]
password = form.cleaned_data["PassWord"]
firstname = form.cleaned_data["FirstName"]
lastname = form.cleaned_data["LastName"]
email = form.cleaned_data["Email"]
user = User.objects.create_user(username, email, password)
user.last_name = lastname
user.first_name = firstname
user.save()
return redirect('subscriber_login_page')
context.update(common)
return render(request, 'auth.html', context)
def get(self, request):
form = self.form_class(request.GET)
if form.is_valid():
data = form.cleaned_data
keyword = data.get('search_text', '')
if data.get('sort_by'):
post_list = Article.objects.filter(Q(title__contains=keyword) | Q(body__contains=keyword)).order_by(
'author__' + data.get('sort_by'))
else:
post_list = Article.objects.filter(Q(title__contains=keyword) | Q(body__contains=keyword))
else:
form = SearchForm()
post_list = Article.objects.all()
# Pagination part
page = request.GET.get('page', 1)
paginator = Paginator(post_list, 6)
try:
page_come = paginator.page(page)
except PageNotAnInteger:
page_come = paginator.page(1)
except EmptyPage:
page_come = paginator.page(paginator.num_pages)
return render(request, self.template_name, {
'form': form,
'post_list': page_come,
'pagination': gen_page_list(page, paginator.num_pages)
})
def post_search(request):
form = SearchForm()
if 'query' in request.GET:
form = SearchForm(request.GET)
if form.is_valid():
cd = form.cleaned_data
results = SearchQuerySet.models(Post).filter(
content=cd['query']).load_all()
# count total results
total_results = results.count()
return render(request, 'blog/post/search.html', {
'form': form,
'cd': cd,
'results': results,
'total_results': total_results
})
def search(request):
global page_article_list, search_list, search_result
try:
if request.method == 'GET':
searchform = SearchForm(request.GET)
if searchform.is_valid():
search_result = searchform.cleaned_data['search']
search_list = Article.objects.filter(category__article__title__icontains=search_result)
print(search_list)
page_article_list = getPage(request, search_list)
print(page_article_list)
except Exception as e:
logger.error(e)
return render(request, 'search.html',
{'article_list': page_article_list, 'search_list': search_list,'search_result':search_result})
def post_search(request):
form = SearchForm()
query = None
results = []
if 'query' in request.GET:
form = SearchForm(request.GET)
if form.is_valid():
query = form.cleaned_data['query']
results = Post.objects.annotate(similarity=TrigramSimilarity(
'title',
query), ).filter(similarity__gt=0.3).order_by('-similarity')
return render(request, 'app/blog.html', {
'form': form,
'query': query,
'results': results
})
def search(request):
search_form = SearchForm(request.GET)
found_articles = []
if search_form.is_valid() and (search_form.cleaned_data["phrase"]
or search_form.cleaned_data["tags"]):
found_articles = (Article.search_articles(
search_form.cleaned_data["phrase"],
search_form.cleaned_data["tags"]))
return render_to_response(
"search.html",
{
"page_title": ugettext("Search"),
"found_articles": found_articles,
"search_form": search_form,
},
context_instance=RequestContext(request),
)
def image_search(query, page=1):
''' Search for images within gallery in admin panel.'''
form = SearchForm(request.form)
images = Photo.objects.search_text(query).order_by('$file_name')
images = images.paginate(page=page, per_page=6)
return render_template('/admin/image_gallery.html',
images=images,
form=form)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
post = self.get_object()
context['comments'] = post.comments.filter(active=True)
context['comment_form'] = CommentForm()
context['search_form'] = SearchForm()
context['similar_posts'] = post.get_similar_posts(n_posts=5)
return context
def search():
searchform = SearchForm()
search = searchform.search.data
like_s = "%{}%".format(str(search))
posts = Post.query.filter(Post.content.like(like_s)).all()
return render_template('search.html',
title='search',
searchform=searchform,
posts=posts)
def post_search(query, page=1):
''' MongoDB text search for admin panel on Post model.'''
form = SearchForm(request.form)
posts = Post.objects.search_text(query).order_by('$text_score')
posts = posts.paginate(page=page, per_page=6)
return render_template('admin/list.html',
posts=posts,
form=form,
cur_endpoint='posts.all_posts')
def post_search(req):
form = SearchForm()
data = None
results = None
total_results = None
if 'query' in req.GET:
form = SearchForm(req.GET)
if form.is_valid():
data = form.cleaned_data
results = SearchQuerySet().models(Post).filter(
content=data['query']).load_all() #Todo
total_results = results.count()
return render(
req, 'blog/post/search.html', {
'form': form,
'data': data,
'results': results,
'total_results': total_results
})
def index_page(request):
categories = BlogPostCategory.objects.all()
new_posts = BlogPost.objects.all()[:2]
search_form = SearchForm()
return render_to_response('post/base_page.html', {
'categories': categories,
'new_posts': new_posts,
'form': search_form
},
context_instance=RequestContext(request))
def search_results(request):
search_form = SearchForm()
if 'query' in request.GET:
form = SearchForm(request.GET)
if form.is_valid():
cd = form.cleaned_data
results = SearchQuerySet().models(Post).filter(content=cd['query']).load_all()
# count total results
total_results = results.count()
return render(request,
'blog/post/search_results.html',
{
'form': form,
'cd': cd,
'results': results,
'total_results': total_results,
'search_form': search_form
})
return HttpResponse('Please submit a search term.')
def post_search(request):
form = SearchForm()
query = None
results = []
if 'query' in request.GET:
form = SearchForm(request.GET)
if form.is_valid():
query = form.cleaned_data['query']
search_vector = SearchVector('title', 'body')
search_query = SearchQuery(query)
results = Post.published.annotate(
search=search_vector,
rank=SearchRank(search_vector, search_query),
).filter(search=search_query).order_by('-rank')
return render(request, 'blog/post/search.html', {
'form': form,
'query': query,
'results': results
})
def unfavourite(post_id, username):
search = SearchForm()
post = Post.query.get_or_404(post_id)
if current_user in post.followers:
post.followers.remove(current_user)
db.session.commit()
flash("Post has been removed from favourites.")
posts = current_user.favourites
comments = Comment.query.filter(Comment.author_id == current_user.id)
return render_template('profile.html', comments=comments, posts=posts, search=search)
def register():
search = SearchForm()
form = RegistrationForm()
if form.validate_on_submit():
user = User(firstname=form.firstname.data, lastname=form.lastname.data, username=form.username.data, email=form.email.data, password=form.password.data)
db.session.add(user)
db.session.commit()
flash('Registration successful.')
return redirect(url_for('home'))
return render_template('register.html', title='Register', form=form, search=search)
def search_by_key_words(request):
needed_posts = []
posts = BlogPost.objects.all()
search_form = SearchForm(request.POST)
if search_form.is_valid():
search_form.save()
d = search_form.cleaned_data
key_words = d['keywords']
key_words = key_words.split()
for key_word in key_words:
for post in posts:
if key_word in post.title or key_word in post.article:
needed_posts.append(post)
return render_to_response('post/posts.html',{'posts':needed_posts,'form':search_form},context_instance=RequestContext(request))
else :
categories = BlogPostCategory.objects.all()
new_posts = BlogPost.objects.all()[:2]
return render_to_response('base.html', {'categories': categories, 'new_posts': new_posts, 'form': search_form},
context_instance=RequestContext(request))
def image_gallery(page=1, sort='-created_at'):
''' Manage images within admin panel.'''
form = SearchForm(request.form)
if request.method == 'POST':
q = form.query.data
return redirect(url_for('posts.image_search', query=q, page=1))
images = Photo.objects.order_by(sort).paginate(page=page, per_page=6)
return render_template('/admin/image_gallery.html',
images=images,
form=form)
def post_comment(post_id):
search = SearchForm()
post = Post.query.get_or_404(post_id)
form = CommentForm()
if form.validate_on_submit():
db.session.add(Comment(content=form.comment.data, post_id=post.id, author_id=current_user.id))
db.session.commit()
flash("Your comment has been added to the post")
return redirect(f'/post/{post.id}')
comments = Comment.query.filter(Comment.post_id == post.id)
return render_template('post.html', post=post, comments=comments, form=form, search=search)
def login():
search = SearchForm()
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if user is not None and user.verify_password(form.password.data):
login_user(user)
flash('Login successful.')
return redirect(url_for('home'))
else:
flash('Invalid email or password.')
return render_template('login.html', title='Login', form=form, search=search)
def search(request):
if request.method == 'POST':
print(request.POST.get('q'))
form = SearchForm(request.POST)
if form.is_valid():
queryset = Post.objects.all()
query = form.cleaned_data.get('q')
if query:
queryset = queryset.filter(
Q(main_title__icontains=query)
| Q(short_description__icontains=query)).distinct()
context = {
'queryset': queryset,
}
return render(request,
template_name='blog/search_results.html',
context=context)
return render(request, template_name='blog/search_results.html')
def post_search(request):
form = SearchForm()
context = dict()
if 'query' in request.GET:
form = SearchForm(request.GET)
# form validation
if form.is_valid():
cd = form.cleaned_data
results = SearchQuerySet().models(Post).filter(
content=cd['query']).load_all()
# count total results
total_results = results.count()
context['cd'] = cd
context['results'] = results
context['total_results'] = total_results
context['form'] = form
return render(request, 'blog/post/search.html', context)
def search_result():
searchform = SearchForm()
search = searchform.search.data
like_s = "%{}%".format(str(search))
if request.method == "POST":
posts = Post.query.filter(
or_(Post.content.like(like_s), Post.title.like(like_s))).all()
return redirect(url_for('search/result'))
return render_template('search.html',
title='search',
posts=posts,
search=search,
searchform=searchform)
def search(request, search_request=None, type_request=None):
try:
template = 'blog/search.html'
args = {}
if request.method == 'POST':
form = SearchForm(request.POST)
if form.is_valid():
request_type = form.cleaned_data['request_type']
request_value = form.cleaned_data['request']
if request_type == 'tag':
existing_tags = [t.tag for t in Tag.objects.all()]
tags = [tag for tag in request_value.split() if tag in existing_tags]
list_post = []
for post in Post.objects.filter(visible=True):
post_tags = [t.tag for t in post.tag.all()]
if all(tag in post_tags for tag in tags):
list_post.append(post)
args.update({'posts': list_post})
elif request_type == 'user':
args.update({'posts': Post.objects.filter(visible=True,
user=User.objects.get(username=request_value))})
elif request_type == 'post':
args.update({'posts': Post.objects.filter(visible=True, title=request_value)})
else:
form = SearchForm()
args.update({'user': request.user})
args.update({'form': form})
except:
raise Http404()
return render_to_response(template, args)
def rss(request):
if request.method == 'GET':
form = SearchForm(initial={'title_word': "."})
return render(request, 'blog/rss.html', {
'form': form,
"lms" : LanMu.objects.all(),
"right": common_content(),
})
if request.method == 'POST':
form = SearchForm(request.POST)
# 探究搜索关键词为空的内容// 搜素全部为 .
if form.is_valid():
tag = form.cleaned_data['tag']
start_date = form.cleaned_data['serach_start']
end_date = form.cleaned_data['serach_end']
word = form.cleaned_data['title_word']
temp_res = Article.objects.all()
result1 = [x for x in temp_res if x.pub_date.date() > start_date and x.pub_date.date() <= end_date]
result0 = [x for x in result1 if x.column == tag]
result = []
for x in result0:
if re.match(".*" + word + ".*", x.title):
result.append(x)
return render(request, "blog/rss.html", {
'form': form,
"blogs": result,
"lms" : LanMu.objects.all(),
"right": common_content(),
})
return render(request, 'blog/rss.html', {
'form': form,
"lms" : LanMu.objects.all(),
"right": common_content(),
})
def subscriber_logout_page(request):
if request.method == 'POST':
logout(request)
return redirect('subscriber_login_page')
else:
searchform = SearchForm()
posts = Post.objects.get_published()[0:6]
context = {
'posts': posts,
'pages': Page.objects.get_published(),
'search': searchform,
}
context.update(common)
return render(request, 'logout.html', context)
