def get(self, request):
session_id = request.session.get('token') # We do not assign here the session
last_activity = request.session.get('last_activity')
request.session['last_activity'] = str(timezone.now()) # Update activity time
# Get visited times
visited_times = request.session.get('visited', 0)
if visited_times == 0:
request.session['visited'] = 0
request.session['visited'] += 1
visited_times = request.session['visited']
# print(request.session.get_expiry_age()) To check if expiry age has been updated
return JsonResponse({
'user_ip': client_ip(request),
'session_id': session_id,
'visited_times': visited_times,
'last_timestamp': last_activity,
'cookies_data': {
'cookie_consent_status': request.COOKIES.get('cookieconsent_status', None),
'session_id': request.COOKIES.get('sessionid', None)
}
})
def getUsrHost(request):
'''
@function: get usr and ip together
@paras:
@returns: (usr, ip) tuple
'''
return getUsr(request), client_ip(request)
def post_ip(request, pk):
post = get_object_or_404(Board, pk=pk)
# posts = Board.objects.all()
ip = client_ip(request)
try:
# ip주소와 게시글 번호로 기록을 조회함
hits = HitCount.objects.get(ip=ip, post=post)
except Exception as e:
# 처음 게시글을 조회한 경우엔 조회 기록이 없음
print(e)
hits = HitCount.objects.create(ip=ip, post_id=post.id)
Board.objects.filter(pk=pk).update(hits=post.hits + 1)
hits.save()
# 상세화면에서 조회수가 바로 바뀌지 않아서 강제로 출력 조회수 +1 시킴
post.hits = post.hits + 1
else:
# 조회 기록은 있으나, 날짜가 다른 경우
if not hits.date == timezone.now().date():
# 테스트할 때 사용
# if not hits.date == timezone.now():
Board.objects.filter(pk=pk).update(hits=post.hits + 1)
hits.date = timezone.now()
hits.save()
post.hits = post.hits + 1
# 날짜가 같은 경우
else:
print(str(ip) + ' has already hit this post.\n\n')
return render(request, 'staff/board_detail.html', {'post': post})
def getUsrHost(request):
'''
@function: get usr and ip together
@paras:
@returns: (usr, ip) tuple
'''
return getUsr(request), client_ip(request)
def webPhising_view(request, cat, name):
# ip, is_routable = get_client_ip(request, request_header_order=['X_FORWARDED_FOR', 'REMOTE_ADDR'])
ip = client_ip(request)
web_objs = get_object_or_404(PhisingWeb, cat_parse=cat, name_parse=name)
TrackRecord.objects.create(web_load=web_objs, ip_host=ip)
content = {'product': web_objs}
return render(request, 'phiser/phiser_view.html', content)
def post_hit(request, pk):
ip_address = client_ip(request)
post = get_object_or_404(Post, pk=pk)
post_view_dupe = post.hit_set.filter(ip_address=ip_address)
if len(post_view_dupe) == 0:
hit = Hit(post=post, ip_address=ip_address)
hit.save()
return HttpResponse("Image", 'Content-Type: image/png')
def post(request, slug):
http_host = request.META['HTTP_HOST']
if http_host == 'bearblog.dev' or http_host == 'localhost:8000':
return redirect('/')
elif 'bearblog.dev' in http_host or 'localhost:8000' in http_host:
extracted = tldextract.extract(http_host)
if is_protected(extracted.subdomain):
return redirect(get_base_root(extracted))
blog = get_object_or_404(Blog, subdomain=extracted.subdomain)
root = get_root(extracted, blog.subdomain)
else:
blog = get_object_or_404(Blog, domain=http_host)
root = http_host
ip_address = client_ip(request)
if request.method == "POST":
upvoted_pose = get_object_or_404(Post, blog=blog, slug=slug)
posts_upvote_dupe = upvoted_pose.upvote_set.filter(
ip_address=ip_address)
if len(posts_upvote_dupe) == 0:
upvote = Upvote(post=upvoted_pose, ip_address=ip_address)
upvote.save()
if request.GET.get('preview'):
all_posts = blog.post_set.annotate(
upvote_count=Count('upvote')).all().order_by('-published_date')
else:
all_posts = blog.post_set.annotate(
upvote_count=Count('upvote')).filter(
publish=True).order_by('-published_date')
post = get_post(all_posts, slug)
upvoted = False
for upvote in post.upvote_set.all():
if upvote.ip_address == ip_address:
upvoted = True
content = markdown(post.content, extensions=['fenced_code'])
return render(
request, 'post.html', {
'blog': blog,
'content': content,
'post': post,
'nav': get_nav(all_posts),
'root': root,
'meta_description': unmark(post.content)[:160],
'upvoted': upvoted
})
def discover(request):
http_host = request.META['HTTP_HOST']
if not (http_host == 'bearblog.dev' or http_host == 'localhost:8000'):
raise Http404("No Post matches the given query.")
if request.method == "POST":
pk = request.POST.get("pk", "")
post = get_object_or_404(Post, pk=pk)
ip_address = client_ip(request)
posts_upvote_dupe = post.upvote_set.filter(ip_address=ip_address)
if len(posts_upvote_dupe) == 0:
upvote = Upvote(post=post, ip_address=ip_address)
upvote.save()
posts_per_page = 20
page = 0
gravity = 1.8
if request.GET.get('page'):
page = int(request.GET.get('page'))
posts_from = page * posts_per_page
posts_to = (page * posts_per_page) + posts_per_page
newest = request.GET.get('newest')
if newest:
posts = Post.objects.annotate(upvote_count=Count('upvote'), ).filter(
publish=True,
show_in_feed=True,
published_date__lte=timezone.now()).order_by(
'-published_date').select_related('blog')[posts_from:posts_to]
else:
posts = Post.objects.annotate(
upvote_count=Count('upvote'),
score=ExpressionWrapper(
((Count('upvote')) /
((Seconds(Now() - F('published_date'))) + 2)**gravity) *
100000,
output_field=FloatField())).filter(
publish=True,
show_in_feed=True,
published_date__lte=timezone.now()).order_by(
'-score', '-published_date').select_related(
'blog')[posts_from:posts_to]
return render(
request, 'discover.html', {
'posts': posts,
'next_page': page + 1,
'posts_from': posts_from,
'gravity': gravity,
'newest': newest,
})
def homel(request):
media = Kurs.objects.all()
tedbr = Eventa.objects.all()
bloge = Blog.objects.all()
ipaddr = client_ip(request)
context = {
'bloge': bloge,
'tedbr': tedbr,
'media': media,
}
return render(request, 'home/homes.html', context)
def time_zone(request):
ipaddr = client_ip(request)
reader = geoip2.database.Reader(
os.path.join(settings.BASE_DIR,
'static\\static_root\\geoip\\GeoLite2-City.mmdb'))
if ipaddr in (
'127.0.0.1',
'192.168.1.10',
):
ipaddr = '109.79.129.171'
try:
response = reader.city(ipaddr)
timezone = response.location.time_zone
except geoip2.errors.AddressNotFoundError:
timezone = None
return timezone
def post(request, slug):
address_info = resolve_address(request)
if not address_info:
return redirect('/')
blog = address_info['blog']
ip_address = client_ip(request)
if request.method == "POST":
upvoted_pose = get_object_or_404(Post, blog=blog, slug=slug)
posts_upvote_dupe = upvoted_pose.upvote_set.filter(
ip_address=ip_address)
if len(posts_upvote_dupe) == 0:
upvote = Upvote(post=upvoted_pose, ip_address=ip_address)
upvote.save()
if request.GET.get('preview'):
all_posts = blog.post_set.annotate(
upvote_count=Count('upvote')).all().order_by('-published_date')
else:
all_posts = blog.post_set.annotate(
upvote_count=Count('upvote')).filter(
publish=True).order_by('-published_date')
post = get_post(all_posts, slug)
upvoted = False
for upvote in post.upvote_set.all():
if upvote.ip_address == ip_address:
upvoted = True
content = mistune.html(post.content)
return render(
request, 'post.html', {
'blog': blog,
'content': content,
'post': post,
'nav': get_nav(all_posts),
'root': address_info['root'],
'meta_description': unmark(post.content)[:160],
'upvoted': upvoted
})
def signup(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
user = form.save()
user.refresh_from_db(
) # load the profile instance created by the signal
user.profile.name = form.cleaned_data.get('name')
user.profile.emailconfirmed = 'True'
user.profile.ipaddress = client_ip(request)
user.save()
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=user.username, password=raw_password)
login(request, user)
return redirect('home')
else:
form = SignUpForm()
return render(request, 'signup.html', {'form': form})
def post(request, slug):
blog = resolve_address(request)
if not blog:
return not_found(request)
ip_address = client_ip(request)
if request.method == "POST":
if request.POST.get("pk", ""):
# Upvoting
pk = sanitise_int(request.POST.get("pk", ""), 7)
post = get_object_or_404(Post, pk=pk)
posts_upvote_dupe = post.upvote_set.filter(ip_address=ip_address)
if len(posts_upvote_dupe) == 0:
upvote = Upvote(post=post, ip_address=ip_address)
upvote.save()
if request.GET.get('preview'):
all_posts = blog.post_set.annotate(
upvote_count=Count('upvote')).all().order_by('-published_date')
else:
all_posts = blog.post_set.annotate(
upvote_count=Count('upvote')).filter(
publish=True).order_by('-published_date')
post = get_post(all_posts, slug)
upvoted = False
for upvote in post.upvote_set.all():
if upvote.ip_address == ip_address:
upvoted = True
meta_description = post.meta_description or unmark(post.content)[:160]
return render(
request, 'post.html', {
'blog': blog,
'content': post.content,
'post': post,
'root': blog.useful_domain(),
'meta_description': meta_description,
'meta_image': post.meta_image or blog.meta_image,
'upvoted': upvoted
})
def post_new(request):
blog = get_object_or_404(Blog, user=request.user)
if not resolve_subdomain(request.META['HTTP_HOST'], blog):
return redirect(f"http://{get_root(blog.subdomain)}/dashboard")
if request.method == "POST":
form = PostForm(request.user, request.POST)
if form.is_valid():
post = form.save(commit=False)
post.blog = blog
post.published_date = timezone.now()
post.save()
upvote = Upvote(post=post, ip_address=client_ip(request))
upvote.save()
return redirect(f"/dashboard/posts/{post.id}/")
else:
form = PostForm(request.user)
return render(request, 'dashboard/post_edit.html', {
'form': form,
'blog': blog
})
def post(request, slug):
blog = get_object_or_404(Blog, user=request.user)
ip_address = client_ip(request)
if request.method == "POST":
if request.POST.get("pk", ""):
# Upvoting
pk = request.POST.get("pk", "")
post = get_object_or_404(Post, pk=pk)
posts_upvote_dupe = post.upvote_set.filter(ip_address=ip_address)
if len(posts_upvote_dupe) == 0:
upvote = Upvote(post=post, ip_address=ip_address)
upvote.save()
if request.GET.get('preview'):
all_posts = blog.post_set.annotate(
upvote_count=Count('upvote')).all().order_by('-published_date')
else:
all_posts = blog.post_set.annotate(
upvote_count=Count('upvote')).filter(
publish=True).order_by('-published_date')
post = get_post(all_posts, slug)
upvoted = False
for upvote in post.upvote_set.all():
if upvote.ip_address == ip_address:
upvoted = True
return render(
request, 'post.html', {
'blog': blog,
'content': post.content,
'post': post,
'root': blog.useful_domain(),
'upvoted': upvoted
})
def process_form(request, form):
if form.is_valid():
# Save entry
entry = models.FormEntry.objects.create(
form=form.form,
ip=client_ip(request),
)
for field in form.form.forms_formfield_set.all():
field_entry = models.FormEntryValue.objects.create(
field=field,
form_entry=entry,
value=form.cleaned_data[field.slug],
)
if isinstance(form.cleaned_data[field.slug], numbers.Number):
field_entry.int_value = form.cleaned_data[field.slug]
field_entry.save()
data = form.form.webhook_dict.copy(
) if form.form.webhook_dict else dict()
data.update(entry.get_values(form.form.get_fields(), json_safe=True))
if form.form.webhook:
requests.post(form.form.webhook, data=data)
if form.form.list_id:
requests.post(mailtrain_subscribe_url(form.form), data=data)
if form.form.mailchimp_connection:
connection = form.form.mailchimp_connection
email = data.pop("email", "").lower().encode("utf-8")
email_hash = hashlib.md5(email).hexdigest()
mailchimp_data = {
"email_address": email,
"status_if_new": "subscribed",
"status": "subscribed",
"ip_signup": entry.ip,
"merge_fields": data,
"tags": [x.strip() for x in form.form.tags.split(',')],
}
headers = {"Content-Type": "application/json"}
auth = ("key", connection.api_key)
url = f"https://{connection.api_server}.api.mailchimp.com/3.0/lists/{form.form.mailchimp_list_id}/members/{email_hash}"
r = requests.put(
url,
json=mailchimp_data,
headers=headers,
auth=auth,
)
data['email'] = email.decode()
if form.form.email:
message = (f"Form: {form.form.title} ({form.form.pk})"
f"\nEntry-ID: {entry.pk}"
f"\nCreated: {entry.created}"
f"\nIP: {entry.ip}"
"\n--------------------------")
for field in form.form.get_fields():
message += f"\n{field}: {data.get(field, '')}"
message += "\n"
emails = [email.strip() for email in form.form.email.split(",")]
send_mail(
f"Form Entry: {form.form.title}",
message,
"*****@*****.**",
emails,
False,
)
data.update({
'ip': entry.ip,
'created': entry.created,
'sid': str(entry.submission_id),
})
if form.form.success_redirect:
response = HttpResponse(status=201)
response["URL"] = form.form.success_redirect.format(**data)
return response
if form.form.success_message:
message = form.form.success_message.replace('%7B', '{').replace(
'%7D', '}').format(**data).replace('{',
'%7B').replace('}', '%7D')
return HttpResponse(message, status=202)
form = form.form.get_instance(None)
return HttpResponse(
render_to_string("forms/form.html", {
"form": form,
"disable_js": True,
}))
def send_tplmsg(request):
""" push_id + title/ip/type/descr/detail/time/remark/color/openids + sign """
text = request.POST.get('text', '') or request.GET.get('text', '')
if not text:
return response()
data = json.loads(text)
# Key for back compatibility
wepush_id = data.get('push_id', '') or data.get('key', '')
reqlog = WeChatTemplateMessageRequestLogInfo.objects.create(
wepush_id=wepush_id,
request_ip=client_ip(request),
request_text=text,
)
try:
tpl = WeChatTemplateInfo.objects.get(wepush_id=wepush_id, status=True)
except WeChatTemplateInfo.DoesNotExist:
return response(WeChatTemplateStatusCode.TEMPLATE_NOT_FOUND)
if not check_signature(data, api_key=tpl.wepush_secret):
reqlog.request_sign_status = False
reqlog.save()
return response(SignatureStatusCode.SIGNATURE_ERROR)
# 调用方指定接收入
openids = json.loads(data.get('openids', '[]'))
if not openids:
# Pushman 配置接收入
receivers = WeChatTemplateReceiverInfo.objects.filter(
wepush_id=tpl.wepush_id)
openids = [receiver.openid for receiver in receivers]
if not openids:
return response(WeChatTemplateStatusCode.RECEIVER_NOT_FOUND)
color = data.get('color', u'#173177')
tpl_data = {
'first': {
'value': data.get('first') or data.get('title', u'服务器故障'),
'color': color,
},
'keyword1': {
'value': data.get('keyword1') or data.get('ip', '127.0.0.1'),
'color': color,
},
'keyword2': {
'value': data.get('keyword2') or data.get('type', u'服务器故障'),
'color': color,
},
'keyword3': {
'value': data.get('keyword3') or data.get('descr', u'服务器故障'),
'color': color,
},
'keyword4': {
'value': data.get('keyword4') or data.get('detail', u'服务器故障'),
'color': color,
},
'keyword5': {
'value':
data.get('keyword5') or data.get('time', tc.local_string())
or tc.local_string(),
'color':
color,
},
'remark': {
'value': data.get('remark', u'请尽快处理！'),
'color': color,
},
}
tplmsg = TemplateMessage(appid=tpl.app_id,
secret=tpl.app_secret,
token=fetch_access_token(tpl.token_url,
tpl.token_key),
storage=RedisStorage(r))
success = failure = 0
for openid in openids:
msgres = tplmsg.send_template_message(user_id=openid,
template_id=tpl.template_id,
data=tpl_data,
url=data.get('url', None))
# Success Or Not
send_status = msgres['errcode'] == 0
# TPL Send Log
WeChatTemplateMessageSendLogInfo.objects.create(
wepush_id=wepush_id,
request_id=reqlog.request_id,
openid=openid,
send_msgres=msgres,
send_status=send_status,
)
# Success/Failure Num Incr
if send_status:
success += 1
else:
failure += 1
return response(200, data={
'success': success,
'failure': failure,
})
def discover(request):
http_host = request.META['HTTP_HOST']
get_object_or_404(Site, domain=http_host)
ip_address = client_ip(request)
if request.method == "POST":
pk = request.POST.get("pk", "")
post = get_object_or_404(Post, pk=pk)
posts_upvote_dupe = post.upvote_set.filter(ip_address=ip_address)
if len(posts_upvote_dupe) == 0:
upvote = Upvote(post=post, ip_address=ip_address)
upvote.save()
posts_per_page = 20
page = 0
gravity = 1.2
if request.GET.get('page'):
page = int(request.GET.get('page'))
posts_from = page * posts_per_page
posts_to = (page * posts_per_page) + posts_per_page
newest = request.GET.get('newest')
if newest:
posts = Post.objects.annotate(upvote_count=Count('upvote'), ).filter(
publish=True,
show_in_feed=True,
published_date__lte=timezone.now()).order_by(
'-published_date').select_related('blog')[posts_from:posts_to]
else:
posts = Post.objects.annotate(
upvote_count=Count('upvote'),
score=ExpressionWrapper(
((Count('upvote')) /
((Seconds(Now() - F('published_date'))) + 2)**gravity) *
100000,
output_field=FloatField()),
).filter(
publish=True,
show_in_feed=True,
published_date__lte=timezone.now()).order_by(
'-score', '-published_date').select_related(
'blog').prefetch_related('upvote_set')[posts_from:posts_to]
upvoted_posts = []
for post in posts:
for upvote in post.upvote_set.all():
if upvote.ip_address == ip_address:
upvoted_posts.append(post.pk)
return render(
request, 'discover.html', {
'site': Site.objects.get_current(),
'posts': posts,
'next_page': page + 1,
'posts_from': posts_from,
'gravity': gravity,
'newest': newest,
'upvoted_posts': upvoted_posts
})
def discover(request):
ip_address = client_ip(request)
if request.method == "POST":
pk = sanitise_int(request.POST.get("pk", ""), 7)
post = get_object_or_404(Post, pk=pk)
posts_upvote_dupe = post.upvote_set.filter(ip_address=ip_address)
if len(posts_upvote_dupe) == 0:
upvote = Upvote(post=post, ip_address=ip_address)
upvote.save()
page = 0
if request.GET.get("page", 0):
page = sanitise_int(request.GET.get("page"), 7)
posts_from = page * posts_per_page
posts_to = (page * posts_per_page) + posts_per_page
newest = request.GET.get("newest")
if newest:
posts = (Post.objects.annotate(upvote_count=Count("upvote"), ).filter(
publish=True,
blog__reviewed=True,
blog__blocked=False,
show_in_feed=True,
published_date__lte=timezone.now(),
).order_by("-published_date").select_related("blog")
[posts_from:posts_to])
else:
posts = (Post.objects.annotate(
upvote_count=Count("upvote"),
score=ExpressionWrapper(
((Count("upvote") - 1) /
((Seconds(Now() - F("published_date"))) + 4)**gravity) *
100000,
output_field=FloatField(),
),
).filter(
publish=True,
blog__reviewed=True,
blog__blocked=False,
show_in_feed=True,
published_date__lte=timezone.now(),
).order_by("-score", "-published_date").select_related(
"blog").prefetch_related("upvote_set")[posts_from:posts_to])
upvoted_posts = []
for post in posts:
for upvote in post.upvote_set.all():
if upvote.ip_address == ip_address:
upvoted_posts.append(post.pk)
return render(
request,
"discover.html",
{
"site": Site.objects.get_current(),
"posts": posts,
"previous_page": page - 1,
"next_page": page + 1,
"posts_from": posts_from,
"gravity": gravity,
"newest": newest,
"upvoted_posts": upvoted_posts,
},
)
def process_form(request, form):
if form.is_valid():
# Save entry
entry = models.FormEntry.objects.create(
form=form.form,
ip=client_ip(request),
)
for field in form.form.forms_formfield_set.all():
field_entry = models.FormEntryValue.objects.create(
field=field,
form_entry=entry,
value=form.cleaned_data[field.slug],
)
if isinstance(form.cleaned_data[field.slug], numbers.Number):
field_entry.int_value = form.cleaned_data[field.slug]
field_entry.save()
data = form.form.webhook_dict.copy(
) if form.form.webhook_dict else dict()
data.update(form.cleaned_data)
if form.form.webhook:
requests.post(form.form.webhook, data=data)
if form.form.list_id:
requests.post(mailtrain_subscribe_url(form.form), data=data)
if form.form.mailchimp_connection:
connection = form.form.mailchimp_connection
email = data.pop('email', '').lower().encode('utf-8')
email_hash = hashlib.md5(email).hexdigest()
mailchimp_data = {
'email_address': email,
'status_if_new': 'subscribed',
'status': 'subscribed',
'ip_signup': entry.ip,
'merge_fields': data,
'tags': (form.form.slug, )
}
headers = {'Content-Type': 'application/json'}
auth = ('key', connection.api_key)
url = f'https://{connection.api_server}.api.mailchimp.com/3.0/lists/{form.form.mailchimp_list_id}/members/{email_hash}'
r = requests.put(
url,
json=mailchimp_data,
headers=headers,
auth=auth,
)
if form.form.email:
message = (f"Form: {form.form.title} ({form.form.pk})"
f"\nEntry-ID: {entry.pk}"
f"\nCreated: {entry.created}"
f"\nIP: {entry.ip}"
"\n--------------------------")
for field in form.form.forms_formfield_set.all():
message += f"\n{field.name}: {form.cleaned_data[field.slug]}"
message += "\n"
emails = [email.strip() for email in form.form.email.split(',')]
send_mail(
f"Form Entry: {form.form.title}",
message,
"*****@*****.**",
emails,
False,
)
if form.form.success_redirect:
response = HttpResponse(status=201)
response["URL"] = form.form.success_redirect
return response
if form.form.success_message:
return HttpResponse(form.form.success_message, status=202)
form = form.form.get_instance(None)
return HttpResponse(
render_to_string("forms/form.html", {
"form": form,
"disable_js": True,
}))
def get_ip(request):
ipaddr = client_ip(request)
print("Public IP address of intruder is:")
print(ipaddr)
return render(request, "fakelogin.html")
def linkhashtag(request, slug='covid19'):
room = Explore.objects.get(slug='covid19')
hash = Explore.objects.all()
post = Post.objects.filter(hashtag=slug)[:4]
likers = Like.objects.all
dic = {'post': post}
users = Profile.objects.get(user=request.user)
users.ipadress = client_ip(request)
users.save()
print(post)
noti = Like.objects.filter(user=request.user)
followpost = Post.objects.filter(user__following__follower=request.user)
followpost = followpost.order_by('date_posted').reverse()
countfollowpost = Post.objects.filter(
user__following__follower=request.user).count()
userlist = Profile.objects.all()
comments = Post.objects.all()
likecountpost = 0
commentcountpost = 0
for live in followpost:
live.user_namepost = str(live.user)
live.namepost = str(live.user.profile.name)
live.postprofilepic = 'https://potatomello.pythonanywhere.com/media/' + str(
live.user.profile.pic)
live.verified = str(live.user.profile.verified)
likecountpost = Like.objects.filter(post=live).count()
commentcountpost = Comments.objects.filter(post=live).count()
live.likepost = str(likecountpost)
live.commentpost = str(commentcountpost)
live.save()
video = ''
if request.method == 'POST':
form = Posting(request.POST, request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.user = request.user
video = post.pic
if str(video).split(".")[-1] == 'mp4':
post.video = 'True'
form.save()
post = Post.objects.filter(hashedshaurl='False')
for iteration in post:
if iteration.hashedshaurl == 'False':
postid = iteration.id
hashid = bytes(str(postid), 'utf-8')
iteration.hashedshaurl = hashlib.sha224(hashid).hexdigest()
iteration.save()
return redirect('link', 'covid19')
else:
form = Posting()
quickpost = Quickpost.objects.all()
quickpost = quickpost.order_by('time').reverse()
countn = 0
n = Notification.objects.filter(viewed='False')
for notification in n:
if notification.foruser in request.user.username:
countn += 1
return render(
request, 'hashtagroom.html', {
'form': form,
'room': room,
'post': post,
'hash': hash,
'likers': likers,
'users': users,
'noti': noti,
'followpost': followpost,
'countfollowpost': countfollowpost,
'userlist': userlist,
'quickpost': quickpost,
'countn': countn,
'notification': n
})
