def post_detail(request, id, page):
post = get_object_or_404(Post, id_post=id)
hit_count = HitCount.objects.get_for_object(post)
HitCountMixin.hit_count(request, hit_count)
if request.method == "POST":
form = CommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.author = request.user
comment.id_post = post
comment.save()
return redirect('post_detail', id=id, page=page)
form = CommentForm()
comments = Comment.objects.filter(id_post=id).order_by('created_date')
p = Paginator(comments, 5)
dict_param = {
'post': post,
'form': form,
'pages': range(1, p.num_pages + 1)
}
if p.num_pages == 0:
dict_param['comments'] = comments
elif p.num_pages <= int(page):
dict_param['comments'] = p.page(p.num_pages)
else:
dict_param['comments'] = p.page(page)
return render(request, 'dairy/post_detail.html', dict_param)
def test_anonymous_user_hit_not_counted(self):
"""
Test Multiple AnonymousUser Hit, not counted
"""
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message, 'Hit counted: session key')
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertFalse(response.hit_counted)
self.assertEqual(response.hit_message, 'Not counted: session key has active hit')
def test_registered_user_hit_not_counted(self):
"""
Test Multiple AnonymousUser Hit, not counted
"""
self.request_post.user = User.objects.create_user('john', '*****@*****.**', 'johnpassword')
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message, 'Hit counted: user authentication')
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertFalse(response.hit_counted)
self.assertEqual(response.hit_message, 'Not counted: authenticated user has active hit')
def test_anonymous_user_hit_not_counted(self):
"""
Test Multiple AnonymousUser Hit, not counted
"""
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message, 'Hit counted: session key')
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertFalse(response.hit_counted)
self.assertEqual(response.hit_message,
'Not counted: session key has active hit')
def get(self, request, pk):
"""Display a question details."""
question = get_object_or_404(QAQuestion, pk=pk)
HitCountMixin.hit_count(request,
HitCount.objects.get_for_object(question))
answers = question.qaanswer_set.all().order_by('-points')
return render(
request, self.template_name, {
'question': question,
'answers': answers,
'num_answer': len(answers),
'rights': settings.QA_SETTINGS['right'],
})
def get_context_data(self, **kwargs):
context = super(QuestionView, self).get_context_data(**kwargs)
question = self.get_object()
hit_count = HitCount.objects.get_for_object(question)
HitCountMixin.hit_count(self.request, hit_count)
if self.request.user.is_authenticated():
context['user_voted'] = not question.votes.exists(self.request.user)
else:
context['user_voted'] = False
context['question'] = question
context['answers'] = sorted(question.answer_set.all(),
key=lambda answer: (answer.votes.count(), answer.create_at), reverse=True)
return context
def participates_in_competition(request):
"""Все опубликованные заявки на участие в конкурсе,
с id конкурса равным competition_id"""
competition_id = request.GET.get('competition_id', 0)
competition = get_object_or_404(Competition, id=competition_id)
add_member = vote_open = False
if competition.status == 2:
exp_date = competition.expiry_date
surv_date = competition.survey_date
if exp_date and surv_date:
if exp_date > timezone.now() < surv_date:
add_member = True
if exp_date > timezone.now() > surv_date:
vote_open = True
participates_list = competition.competition_participates.filter(
status=2).all()
paginator = Paginator(participates_list, CONTENT_COUNT_IN_PAGE)
page = request.GET.get('page')
try:
participates = paginator.page(page)
except PageNotAnInteger:
participates = paginator.page(1)
except EmptyPage:
participates = page.page(paginator.num_pages)
winners = []
if competition.expiry_date < timezone.now():
winners = participates_list.annotate(participate_vote=Count(
'participate_votes', distinct=True)).order_by(
'-participate_vote', 'publish_date')[:3]
hit_count = HitCount.objects.get_for_object(competition)
HitCountMixin.hit_count(request, hit_count)
competition_form = CompetitionForm(instance=competition)
context = {
'participates': participates,
'add_member': add_member,
'competition': competition,
'competition_form': competition_form,
'vote_open': vote_open,
'winners': winners
}
return render(request, "vote/participates.html", context)
def module(request, moduleid):
""" A particular module's contents """
context_dict = {}
module = Module.objects.get(id=moduleid)
context_dict['module_title'] = module.title
context_dict['module_id'] = moduleid
if request.user.is_authenticated():
user = request.user
if Administrator.objects.filter(user=user).exists():
context_dict['is_admin'] = True
context_dict['pages'] = module.page_set.all()
# count user hits
hit_count_obj = HitCount.objects.get_for_object(module)
hit_count_response = HitCountMixin.hit_count(request, hit_count_obj)
context_dict['visits'] = module.hit_count.hits
# Pages query returns ordered tuple (no need to label each page)
context_dict['module_pages'] = tuple(i for i in Page.objects.filter(module=module))
try:
context_dict['user_progress_on_module'] = Takers.objects.get(user=request.user, module=module).progress
except ObjectDoesNotExist:
# if user isn't taking this module -> 0 progress
context_dict['user_progress_on_module'] = 0
context_dict['user_modules'] = tuple(i.module for i in Takers.objects.filter(user=request.user))
context_dict['module_downloadable'] = tuple(i for i in ContentFile.objects.filter(module=module))
return render(request, 'lfs/content.html', context_dict)
def loginuser(request):
if request.user.is_authenticated:
return redirect('index')
else:
if request.method == 'POST':
form = AuthenticationForm(data=request.POST)
if form.is_valid:
user = request.POST['username']
password = request.POST['password']
access = authenticate(request,
username=user,
password=password)
if access is not None:
login(request, access)
if access.is_active:
hit_count = HitCount.objects.get_for_object(
User.objects.get(username=user)
) # hit_count dla poszczególnych wierszy (kluczy)
hit_count_response = HitCountMixin.hit_count(
request, hit_count)
next_url = request.GET.get('next')
if next_url and not next_url[4:][:10] == 'logoutuser':
return redirect(next_url)
else:
return redirect('index')
else:
form = AuthenticationForm()
return render(request, 'reload/login.html', {'form': form})
def book_detail_view(request, book_id):
book = get_object_or_404(Book, id=book_id)
# first get the related HitCount object for your model object
hit_count = HitCount.objects.get_for_object(book)
hit_count_response = HitCountMixin.hit_count(request, hit_count)
return render(request, "book/book_detail.html", {"book": book})
def dispatch(self, request, *args, **kwargs):
hit_count, created = HitCount.objects.get_or_create(
content_type=ContentType.objects.get_for_model(loads), object_pk=0
) # małe oszustwo: ustawiam pk=0 - dla wszystkich pk w loads
hit_count_response = HitCountMixin.hit_count(request, hit_count)
return super(LoadFilteredTable, self).dispatch(request, *args,
**kwargs)
def post(request):
post = Post.objects.get(pk=request.GET.get("id"))
hit_count = HitCount.objects.get_for_object(post)
res = HitCountMixin.hit_count(request, hit_count) # count hit
latest_Posts = list(Post.objects.order_by("-date").all()[:3])
author_Posts = list(
Post.objects.order_by("-date").filter(author=post.author.id)[:2])
event_images = EventImage.objects.all()[:9]
comments = list(
Comment.objects.order_by("-date").filter(post=post.id, approved=True))
most_recent_categories = sorted([i for i in Category.objects.all()],
key=lambda x: x.post_set.count())[::-1][:5]
return render(
request, "post.html", {
"event_images": event_images,
"comments": comments,
"author_Posts": author_Posts,
"post": post,
"latest_Posts": latest_Posts,
'recent_categories': most_recent_categories,
'categories': post.category.all(),
'hits': post.hit_count.hits
})
def test_registered_user_hit_not_counted(self):
"""
Test Multiple AnonymousUser Hit, not counted
"""
self.request_post.user = User.objects.create_user(
'john', '*****@*****.**', 'johnpassword')
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message,
'Hit counted: user authentication')
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertFalse(response.hit_counted)
self.assertEqual(response.hit_message,
'Not counted: authenticated user has active hit')
def record_hit(self, request):
if request.user != self.image.user:
UpdateHitCountResponse = namedtuple('UpdateHitCountResponse',
'hit_counted hit_message')
hit_count: HitCount = HitCount.objects.get_for_object(self.image)
hit_count_response: UpdateHitCountResponse = HitCountMixin.hit_count(
request, hit_count)
return hit_count_response
def article(request, slug):
context = {}
context['article'] = Article.objects.get(slug=slug)
context['meta'] = get_object_or_404(Article, slug=slug).as_meta(request)
hit_count = HitCount.objects.get_for_object(context['article'])
hit_count_response = HitCountMixin.hit_count(request, hit_count) # noqa
return TemplateResponse(request, "frontend/blog/post.html", context)
def test_anonymous_user_hit(self):
"""
Test AnonymousUser Hit
"""
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message, 'Hit counted: session key')
def test_anonymous_user_hit(self):
"""
Test AnonymousUser Hit
"""
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message, 'Hit counted: session key')
def article(request, slug):
context = {}
context['article'] = Article.objects.get(slug=slug)
context['meta'] = get_object_or_404(Article, slug=slug).as_meta(request)
hit_count = HitCount.objects.get_for_object(context['article'])
hit_count_response = HitCountMixin.hit_count(request, hit_count)
return TemplateResponse(request, "frontend/blog/post.html", context)
def register_hit_count(page, request, serve_args, serve_kwargs):
# get hit_count for page
hit_count = HitCount.objects.get_for_object(page)
# attempt to register hit
hit_count_response = HitCountMixin.hit_count(request, hit_count)
return
'''
def post_detail(request, pk):
post = get_object_or_404(Post, pk=pk)
user_name = auth.get_user(request)
ip = request.session['ip']
hit_count = HitCount.objects.get_for_object(post)
hit_count_response = HitCountMixin.hit_count(request, hit_count)
#print ("hit---- " + str(hit_count_response.hit_message))
if request.user.is_authenticated:
if PostPreferrence.objects.filter(username=user_name, ip_address=ip, postpk=pk, vote_value=1).exists():
voted = True
else:
voted = False
else:
if PostPreferrence.objects.filter(ip_address=ip, postpk=pk, vote_value=1).exists():
voted = True
else:
voted = False
try:
total_yes = PostPreferrence.objects.filter(vote_value=1, postpk=pk).count()
except PostPreferrence.DoesNotExist:
total_yes = 0;
#Polling questions and stats
if(PollAnswer.objects.filter(post=pk, user=user_name)).exists():
pollquestion = get_object_or_404(PollQuestions, post=pk)
polled = True
bar_chart = PollHorizontalBarChart(print_values=True,value_formatter=lambda x: '{}%'.format(x),
legend_at_bottom=True,
legend_box_size=30,
style=pygal.style.styles['default'](legend_font_size=30,
value_font_size=30,
label_font_size=25,
))
chart = bar_chart.generate(pollquestion)
else:
pollquestion = get_object_or_404(PollQuestions, post=pk)
polled = False
chart = None
summary = ({
'voted':voted,
'total_yes': total_yes,
'polled': polled,
'pollquestion': pollquestion,
})
return render(request, 'blog/post_detail_index.html',
{'post': post,
'summary': summary,
'barchart': chart,
})
def test_anonymous_user_hit_counted_after_filter_active(self):
"""
Test Multiple AnonymousUser Hit, counted because of filter active
"""
# create a Hit ten days ago
created = timezone.now() - timedelta(days=10)
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = created
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message, 'Hit counted: session key')
# test a Hit today, within the filter time
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message, 'Hit counted: session key')
def test_blacklist_ip(self):
"""
Test black listed IPs.
"""
BlacklistIP.objects.create(ip="127.0.0.1")
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertFalse(response.hit_counted)
self.assertEqual(response.hit_message, 'Not counted: user IP has been blacklisted')
def retrieve(self, request, *args, **kwargs):
instance = self.get_object()
# counting article hits
hit_count = HitCount.objects.get_for_object(instance)
hit_count_response = HitCountMixin.hit_count(request, hit_count)
serializer = self.get_serializer(instance)
return Response(serializer.data)
def test_blacklist_user_agent(self):
"""
Test black listed user agents.
"""
BlacklistUserAgent.objects.create(user_agent="my_clever_agent")
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertFalse(response.hit_counted)
self.assertEqual(response.hit_message, 'Not counted: user agent has been blacklisted')
def userprofile(request, author):
'''
Creates the user profile for a user
Parameters:
request -> request to the user profile page (userprofile.html)
author (str) -> the name of the author / user
Returns:
render -> Loads the user profile page to the user
'''
userPosts = Post.objects.all().filter(
author__username=author).order_by('created_on').reverse()
for post in userPosts:
post.commentCount = len(post.comment_set.all())
for post in userPosts: # Generate mailto link (html href doesn't allow concatenation of strings)
post.reportLink = "mailto:[email protected]?Subject=Flagged%20-%20" + post.title + "%20(Reason%20below)"
context = {
'posts': userPosts,
'authenticated': request.user.is_authenticated(),
'username': author
}
if len(userPosts) > 0:
context['post'] = userPosts[0]
else:
context['post'] = None
if request.method == "POST":
post = context['post']
form = CommentForm(request.POST or None)
hit_count = HitCount.objects.get_for_object(post)
hit_count_response = HitCountMixin.hit_count(request, hit_count)
if form.is_valid():
comment = form.save(commit=False)
comment.post = post
try:
comment.name = request.user
except Exception as e:
print("Exception when trying to set a comment's name: {0}".
format(str(e)))
comment.save()
return redirect(request.path)
else:
print(form.is_valid())
print(form.errors)
post_info(userPosts, context)
return render(request, 'webapp/userprofile.html', context)
def get(self, request, slug):
""" Return detail blogpost information """
post = self.get_object(slug)
serializer = PostDetailSerializer(post, context={'request': request})
hit_count = HitCount.objects.get_for_object(post)
hit_count_response = HitCountMixin.hit_count(request, hit_count)
return Response(serializer.data)
def test_blacklist_ip(self):
"""
Test black listed IPs.
"""
BlacklistIP.objects.create(ip="127.0.0.1")
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertFalse(response.hit_counted)
self.assertEqual(response.hit_message,
'Not counted: user IP has been blacklisted')
def test_blacklist_user_agent(self):
"""
Test black listed user agents.
"""
BlacklistUserAgent.objects.create(user_agent="my_clever_agent")
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertFalse(response.hit_counted)
self.assertEqual(response.hit_message,
'Not counted: user agent has been blacklisted')
def test_anonymous_user_hit_counted_after_filter_active(self):
"""
Test Multiple AnonymousUser Hit, counted because of filter active
"""
# create a Hit ten days ago
created = timezone.now() - timedelta(days=10)
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = created
response = HitCountMixin.hit_count(self.request_post,
self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message, 'Hit counted: session key')
# test a Hit today, within the filter time
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message, 'Hit counted: session key')
def get(self, request, **kwargs):
self.object = self.get_object()
hit_count = HitCount.objects.get_for_object(self.object)
# next, you can attempt to count a hit and get the response
# you need to pass it the request object as well
hit_count_response = HitCountMixin.hit_count(request, hit_count)
context = self.get_context_data(object=self.object)
print("hit count is", hit_count_response)
return self.render_to_response(context)
def test_registered_user_hit_counted_after_filter_active(self):
"""
Test Multiple AnonymousUser Hit, counted because of filter active
"""
self.request_post.user = User.objects.create_user('john', '*****@*****.**', 'johnpassword')
# create a Hit ten days ago
created = timezone.now() - timedelta(days=10)
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = created
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message, 'Hit counted: user authentication')
# test a Hit today, within the filter time
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message, 'Hit counted: user authentication')
def test_exclude_user_group(self):
"""
Exclude user by adding a group setting.
"""
self.request_post.user = User.objects.create_user('john', '*****@*****.**', 'johnpassword')
group = Group.objects.create(name='Admin')
group.user_set.add(self.request_post.user)
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertFalse(response.hit_counted)
self.assertEqual(response.hit_message, 'Not counted: user excluded by group')
def blog(request, slug):
#try and except
try:
blog = Blog.objects.get(slug=slug)
hit_count = HitCount.objects.get_for_object(blog)
print(HitCountMixin.hit_count(request, hit_count))
except Blog.DoesNotExist:
raise Http404
return render(request, 'blog.html', {'blog': blog})
def update_views(request, object):
context = {}
hit_count = get_hitcount_model().objects.get_for_object(object)
hits = hit_count.hits
hitcontext = context["hitcount"] = {"pk": hit_count.pk}
hit_count_response = HitCountMixin.hit_count(request, hit_count)
if hit_count_response.hit_counted:
hits = hits + 1
hitcontext["hitcounted"] = hit_count_response.hit_counted
hitcontext["hit_message"] = hit_count_response.hit_message
hitcontext["total_hits"] = hits
def hit(self, request, pk):
UpdateHitCountResponse = namedtuple('UpdateHitCountResponse', 'hit_counted hit_message')
post: Post = get_object_or_None(self.queryset, pk=pk)
if post and request.user != post.user:
hit_count: HitCount = HitCount.objects.get_for_object(post)
hit_count_response: UpdateHitCountResponse = HitCountMixin.hit_count(request, hit_count)
return HttpResponse(simplejson.dumps(hit_count_response))
return HttpResponse(
simplejson.dumps(UpdateHitCountResponse(False, 'Hit from author or moderated or missing post ignored'))
)
def test_exclude_user_group(self):
"""
Exclude user by adding a group setting.
"""
self.request_post.user = User.objects.create_user(
'john', '*****@*****.**', 'johnpassword')
group = Group.objects.create(name='Admin')
group.user_set.add(self.request_post.user)
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertFalse(response.hit_counted)
self.assertEqual(response.hit_message,
'Not counted: user excluded by group')
def view_video(self, request):
result = False
views = get_object_or_404(VideoViews, pk=self.video_views_id)
hit_count = HitCount.objects.get_for_object(views)
hits_before = hit_count.hits
hit_count_response = HitCountMixin.hit_count(request, hit_count)
result = hit_count_response.hit_counted
if result:
self.video_views = hits_before + 1
self.save()
return result
def get(self, request, **kwargs):
self.object = self.get_object()
hit_count = HitCount.objects.get_for_object(self.object)
# next, you can attempt to count a hit and get the response
# you need to pass it the request object as well
hit_count_response = HitCountMixin.hit_count(request, hit_count)
context = self.get_context_data(object=self.object)
data_review = Review.objects.filter(content_id=self.object.pk,
content_type='document',
published=True)
##########################Review pagination add########################
#print(len(data_review))
length = len(data_review)
number_per_page = 15
if length > number_per_page:
#print("inside pagination")
# for pagination we have following code
paginator = Paginator(data_review, number_per_page)
page = request.GET.get('page')
try:
users = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
users = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 7777), deliver last page of results.
users = paginator.page(paginator.num_pages)
context["paginated_data"] = users
########################Review Pagination end########################
favourite_data = ""
# favourite item data extractions
if request.user.is_authenticated:
favourite_data = Favourite.objects.filter(
favourite_item_id=self.object.pk,
favourite_item_type='document',
user=request.user)
if length > 0 and length <= number_per_page:
context["data_review"] = data_review
context["favourite_data"] = favourite_data
# print("favourite_data=",context["favourite_data"])
# print("context= ", context)
#print("user in the console= ",context["favourite_data"][0].user)
return self.render_to_response(context)
def participate_manage(request):
"""Все заявки в конкурсе, созданном текущим пользователем"""
competition_id = request.GET.get('competition_id', 0)
competition = get_object_or_404(Competition, id=competition_id)
if competition.creator != request.user:
raise Http404
participates_list = competition.competition_participates.all()
paginator = Paginator(participates_list, CONTENT_COUNT_IN_PAGE)
page = request.GET.get('page')
try:
participates = paginator.page(page)
except PageNotAnInteger:
participates = paginator.page(1)
except EmptyPage:
participates = page.page(paginator.num_pages)
hit_count = HitCount.objects.get_for_object(competition)
HitCountMixin.hit_count(request, hit_count)
return render(request, "vote/participate_manage.html", {
'participates': participates,
'competition': competition
})
def test_registered_user_hit_counted_after_filter_active(self):
"""
Test Multiple AnonymousUser Hit, counted because of filter active
"""
self.request_post.user = User.objects.create_user(
'john', '*****@*****.**', 'johnpassword')
# create a Hit ten days ago
created = timezone.now() - timedelta(days=10)
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = created
response = HitCountMixin.hit_count(self.request_post,
self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message,
'Hit counted: user authentication')
# test a Hit today, within the filter time
response = HitCountMixin.hit_count(self.request_post, self.hit_count)
self.assertTrue(response.hit_counted)
self.assertEqual(response.hit_message,
'Hit counted: user authentication')
def lireArticle(request, slug):
article = get_object_or_404(Article, slug=slug)
if not article.estPublic and (request.user.is_anonymous
or not request.user.is_membre_collectif):
return render(
request,
'notPermacat.html',
)
commentaires = Commentaire.objects.filter(
article=article).order_by("date_creation")
dates = Evenement.objects.filter(article=article).order_by("start_time")
hit_count = HitCount.objects.get_for_object(article)
hit_count_response = HitCountMixin.hit_count(request, hit_count)
form = CommentaireArticleForm(request.POST or None)
if form.is_valid():
comment = form.save(commit=False)
if comment:
comment.article = article
comment.auteur_comm = request.user
article.date_dernierMessage = comment.date_creation
article.dernierMessage = (
"(" + str(comment.auteur_comm) + ") " +
str(strip_tags(comment.commentaire).replace('&nspb',
' ')))[:96] + "..."
article.save()
comment.save()
url = article.get_absolute_url() + "#idConversation"
suffix = "_permacat" if article.estPublic else ""
action.send(request.user,
verb='article_message' + suffix,
action_object=article,
url=url,
description="a réagi à l'article: '%s'" %
article.titre)
return redirect(request.path)
return render(
request,
'blog/lireArticle.html',
{
'article': article,
'form': form,
'commentaires': commentaires,
'dates': dates
},
)
def event(request, slug):
"""
Мероприятие
:param request:
:param slug:
:return:
"""
context = {}
context['event'] = Event.objects.get(slug=slug)
date = abs(context['event'].end - context['event'].start)
context['time'] = date.seconds / 60
hit_count = HitCount.objects.get_for_object(context['event'])
hit_count_response = HitCountMixin.hit_count(request, hit_count) # noqa
context['meta'] = get_object_or_404(Event, slug=slug).as_meta(request)
context['datetime_now'] = timezone.now()
return TemplateResponse(request, "frontend/event/event.html", context)
def UserProfileDetailView(request, pk):
userProfile = models.User.objects.get(pk=pk).userprofile
if request.GET.get('count_hit'):
hit_count = HitCount.objects.get_for_object(userProfile)
hit_count_response = HitCountMixin.hit_count(request, hit_count)
if(hit_count_response[0]):
userProfile.num_views = F('num_views') + 1
userProfile.save()
userProfile.refresh_from_db()
fields = utils.to_dict(userProfile)
if(fields['department']):
fields['dept_name'] = models.Dept.objects.get(
id=fields['department']).name
else:
fields['dept_name'] = None
fields['interest_names'] = userProfile.get_interest_names()
fields['isModerator'] = models.Moderator.objects.filter(user__id=fields['user']).exists()
profile_dict = {'model': "app.userprofile",
'pk': fields['id'], 'fields': fields}
return JsonResponse(profile_dict)
def render_to_response(self, context, **response_kwargs):
obj = context.get('object')
instance = self.get_object()
try: # if num_views field exists, update it
a = instance.num_views # crude test for existence
except:
pass
else:
hit_count = HitCount.objects.get_for_object(instance)
hit_count_response = HitCountMixin.hit_count(
self.request, hit_count)
if(hit_count_response[0]):
instance.num_views = F('num_views') + 1
instance.save()
fields = utils.to_dict(obj)
if 'tags' in fields:
fields['tag_names'] = obj.get_tag_names()
response = {'fields': fields, 'pk': obj.pk,
'model': str(obj.__class__)[8:-2]}
return JsonResponse(response)
def test_hits_per_ip_limit(self):
"""
Test `HITCOUNT_HITS_PER_IP_LIMIT` setting. Should allow multiple hits
from the same IP until the limit is reached from that IP.
"""
responses = []
for x in range(3):
# need a new session key each time.
engine = import_module(settings.SESSION_ENGINE)
store = engine.SessionStore()
store.save()
self.request_post.session = store
responses.append(HitCountMixin.hit_count(self.request_post, self.hit_count))
self.assertTrue(responses[0].hit_counted)
self.assertEqual(responses[0].hit_message, 'Hit counted: session key')
self.assertTrue(responses[1].hit_counted)
self.assertEqual(responses[1].hit_message, 'Hit counted: session key')
self.assertFalse(responses[2].hit_counted)
self.assertEqual(responses[2].hit_message, 'Not counted: hits per IP address limit reached')
hit_count = HitCount.objects.get(pk=self.hit_count.pk)
self.assertEqual(hit_count.hits, 2)
def humor_detail(request, pk):
humor_post_from_db=Humor_post.objects.get(pk=pk)
humor_hitcount=HitCount.objects.get_for_object(humor_post_from_db)
humor_hitcount_response=HitCountMixin.hit_count(request, humor_hitcount)
return render(request, 'humor/humor_detail.html', {'humor_post_from_db':humor_post_from_db, 'humor_hitcount_response':humor_hitcount_response})
def redirect(request, linkpattern):
link = get_object_or_404(Link, pattern=linkpattern)
hit_count = HitCount.objects.get_for_object(link)
hit_count_response = HitCountMixin.hit_count(request, hit_count)
return HttpResponseRedirect(link.domain)
def life_detail(request, pk):
life_post_from_db=Life_post.objects.get(pk=pk)
life_hitcount=HitCount.objects.get_for_object(life_post_from_db)
life_hitcount_response=HitCountMixin.hit_count(request, life_hitcount)
return render(request, 'life/life_detail.html', {'life_post_from_db':life_post_from_db, 'life_hitcount_response':life_hitcount_response})
