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