Пример #1
0
    def test_auto_unfollow_on_edited_project(self):
        # first change project that more users follow the project
        project_settings_changed = project_settings.copy()
        project_settings_changed['developer'] = (self.user2.pk)
        project_settings_changed["manager"] = (self.user.pk, self.user3.pk)
        self.client.post(
            reverse('project:edit',
                    kwargs={'project':
                            project_settings_changed['name_short']}),
            project_settings_changed)

        # first remove a manager again
        project_settings_changed["manager"] = (self.user.pk)
        self.client.post(
            reverse('project:edit',
                    kwargs={'project':
                            project_settings_changed['name_short']}),
            project_settings_changed)
        self.assertNotIn(self.user3, followers(self.project))
        self.assertIn(self.user, followers(self.project))

        # second remove a developer again
        del project_settings_changed["developer"]
        self.client.post(
            reverse('project:edit',
                    kwargs={'project':
                            project_settings_changed['name_short']}),
            project_settings_changed)
        self.assertNotIn(self.user2, followers(self.project))
Пример #2
0
 def handle(self, *args, **options):
     self.stdout.write('\n Creating Post/Answers for testing: \n\n')
     consultants = Consultant.objects.all()
     for circle in Circle.objects.all():
         users = followers(circle)
         if len(users) < 5:
             for consultant in set(
                     random.choices(consultants, k=random.randint(2, 10))):
                 circle.add_user(consultant.user)
             users = followers(circle)
         for i in range(random.randint(2, 10)):
             user = random.choices(users, k=1)[0]
             post = Post.objects.create_circle_post(
                 user_from=user,
                 circle=circle,
                 title=' '.join(faker.words()),
                 description=faker.text(),
                 tags=random.choices(Keyword.objects.all(),
                                     k=random.randint(2, 6)),
             )
             for consultant in set(
                     random.choices(consultants, k=random.randint(2, 10))):
                 post.see(consultant.user)
             for consultant in set(
                     random.choices(consultants, k=random.randint(2, 10))):
                 post.see(consultant.user)
                 post.reply(consultant.user, faker.text())
     self.stdout.write('\n Finish!! \n\n')
Пример #3
0
def feeds_fanout_posted(action):
    """Populate users feeds from the given action."""
    # Define list of processed users (to prevent multiple timeline
    # entries for the same post)
    processed_users = []

    def add_to_timeline(user, action):
        user.feed_entries.create(
            category='timeline',
            action=action,
        )
        log.debug('Adding post activity %i to user %i timeline' %
                  (action.id, user.id))
        processed_users.append(user)

    # Add to the timeline of the post owner
    add_to_timeline(action.actor, action)

    # Find followers of user
    for follower in models_actstream.followers(action.actor):
        add_to_timeline(follower, action)

    for tag in action.action_object.tags.all():
        for follower in models_actstream.followers(tag):
            if follower in processed_users:
                log.debug('Skip adding post to timeline, it exists already')
                continue
            add_to_timeline(follower, action)
Пример #4
0
def Company_Detail (request,pk = "", slug = ""):

	try:
		company = Company.objects.get(pk = pk)
	except Company.DoesNotExist:
		raise Http404

	if request.method == "POST":
		if 'follow' in request.POST:
			follow_id = request.POST.get('follow', False)
			if follow_id:
				try:
					company_id = Company.objects.get(pk=follow_id)
					follow(request.user, company_id)
					#request.user.get_profile().applicant
				except Company.DoesNotExist:
					return render(request, 'company_detail.html', {'id': company,'follow':False })
		else:
			unfollow_id = request.POST.get('unfollow', False)
			if unfollow_id:
				try:
					company_id = Company.objects.get(pk=unfollow_id)
					unfollow(request.user, company_id)
					#request.user.get_profile().applicant
				except Company.DoesNotExist:
					return render(request, 'company_detail.html', {'id': company,'follow':True })
	if followers(company):
		print followers(company)
		return render(request, 'company_detail.html', {'id': company,'follow':False })
	return render(request, 'company_detail.html', {'id': company,'follow':True })
 def test_followers_with_flag(self):
     self.assertEqual(list(followers(self.another_group, flag='liking')),
                      [self.user4])
     self.assertEqual(list(followers(self.another_group, flag='watching')),
                      [self.user4])
     self.assertEqual(list(followers(self.user1, flag='liking')),
                      [self.user4])
     self.assertEqual(list(followers(self.user3, flag='blacklisting')),
                      [self.user4])
Пример #6
0
 def test_auto_follow_on_created_project(self):
     # create a second project with the second user as developer
     project2_settings = {
         'name': 'test_project2',
         'name_short': 'tp2',
         'description': 'test2',
         'developer': (self.user2.pk),
     }
     self.client.post(reverse('project:create'), project2_settings)
     newProject = Project.objects.filter(
         name_short=project2_settings['name_short']).first()
     self.assertIn(self.user, followers(newProject))
     self.assertIn(self.user2, followers(newProject))
Пример #7
0
def listeFollowers(request):
    if not request.user.is_permacat:
        return render(request, "notPermacat.html")
    listeArticles = []
    for art in Article.objects.all():
        suiveurs = followers(art)
        if suiveurs:
            listeArticles.append({"titre": art.titre, "url": art.get_absolute_url(), "followers": suiveurs, })
    for art in Projet.objects.all():
        suiveurs = followers(art)
        if suiveurs:
            listeArticles.append({"titre": art.titre, "url": art.get_absolute_url(), "followers": suiveurs, })

    return render(request, 'listeFollowers.html', {"listeArticles":listeArticles})
Пример #8
0
def handle_follow_unfollow_on_archive_unarchive(sender, instance, *args,
                                                **kwargs):
    try:
        old = Issue.objects.get(project=instance.project,
                                number=instance.number)
    except ObjectDoesNotExist:
        return

    # unfollow/follow in archive/unarchive (activity stream)
    if not old.archived and instance.archived:
        for user in followers(instance.project):
            unfollow_issue(user, instance)
    if old.archived and not instance.archived:
        for user in followers(instance.project):
            follow_issue(user, instance)
Пример #9
0
 def get_context_data(self, **kwargs):
     """Adds visible requests and followers to project context"""
     context = super(ProjectDetailView, self).get_context_data(**kwargs)
     project = context["object"]
     user = self.request.user
     context["sidebar_admin_url"] = reverse(
         "admin:project_project_change", args=(project.pk,)
     )
     visible_requests = project.requests.get_viewable(user).select_related(
         "agency__jurisdiction__parent__parent", "composer__user__profile"
     )
     context["visible_requests"] = visible_requests.get_public_file_count(limit=6)
     context["visible_requests_count"] = visible_requests.count()
     articles = project.articles.get_published().prefetch_related(
         Prefetch("authors", queryset=User.objects.select_related("profile"))
     )
     context["articles"] = articles[:3]
     context["articles_count"] = articles.count()
     context["followers"] = followers(project)
     context["contributors"] = project.contributors.select_related("profile")
     context["user_is_experimental"] = (
         user.is_authenticated and user.profile.experimental
     )
     context["newsletter_label"] = (
         "Subscribe to the project newsletter"
         if not project.newsletter_label
         else project.newsletter_label
     )
     context["newsletter_cta"] = (
         "Get updates delivered to your inbox"
         if not project.newsletter_cta
         else project.newsletter_cta
     )
     context["user_can_edit"] = project.editable_by(user)
     return context
Пример #10
0
    def get_user_followers(self):
        '''
		people that follow self.request.user
		'''

        follower = followers(self.request.user)[:6]
        return follower
Пример #11
0
def to_premium_handle(bet_group_id):
    # from premium: there is no need to auto unfollow the bet group. When the existing subscriptions expire
    # the auto unfollow will happen.
    try:
        bet_group = BetTag.objects.get(id=bet_group_id)
    except BetTag.DoesNotExist as e:
        logger.debug('%s', e)
        return
    owner = bet_group.owner
    owner_followers = followers(owner)
    if not owner_followers:
        return
    # owner_followers_ids = owner_followers.values_list('id', flat=True)
    subject = 'Your tipster {} offers a new Premium service!'.format(
        owner.username)
    html_template = 'bet_tagging/to_premium.html'
    text_template = 'bet_tagging/to_premium.txt'
    context = {
        'domain': Site.objects.get_current().domain,
        'bet_group': bet_group
    }
    to_list = []
    recipient_variables = {}
    for user in owner_followers:
        to_list.append(user.email)
        recipient_values = {
            "username": user.username,
            "id": user.id,
        }
        recipient_variables[user.email] = recipient_values
    recipient_variables = json.dumps(recipient_variables)
    res = emails.utils.mailgun_send(to_list, subject, text_template,
                                    html_template, context,
                                    recipient_variables)
    logger.debug("send mailgun mails function returned %s", res)
Пример #12
0
 def bet_group_create_handle(cls, bet_group_id):
     """ When a new Free bet group is created, new notification subscription entries are created
     for the existing user followers """
     logger.debug('bet_group_create_handle...')
     try:
         bet_group = BetTag.objects.get(id=bet_group_id)
     except Exception as e:
         logger.warning('%s', e)
         return
     if not bet_group.type == BetTag.free:
         return
     user_followers = followers(bet_group.owner)
     if not user_followers:
         return
     notification_subscriptions = []
     for user in user_followers:
         try:
             notification_subscription = cls.objects.create(
                 user=user, bet_group=bet_group)
             notification_subscriptions.append(notification_subscription)
         except Exception as e:
             logger.error('%s', e)
     logger.debug('%s notification_subscriptions were created',
                  len(notification_subscriptions))
     return notification_subscriptions
Пример #13
0
def projets_suivis(request, slug):
    projet = Projet.objects.get(slug=slug)
    suiveurs = followers(projet)
    return render(request, "blog/projets_suivis.html", {
        'suiveurs': suiveurs,
        "projet": projet
    })
Пример #14
0
    def run(self, *args, **kwargs):
        try:
            answer = Answer.objects.get(pk=kwargs.get('answer_pk'))
        except Answer.DoesNotExist:
            return
        action = kwargs.get('action')
        post = answer.post
        context = {}

        if post.qa_session:
            qa_team = post.qa_sessions.first()
            following = qa_team.get_available_users(search='')
            context['project'] = post.project
            serializer = AnswerPostSwarmSerializer(answer, context=context)
        else:
            if post.is_project:
                context['project'] = post.project
            following = followers(post)
            serializer = AnswerPostSerializer(answer, context=context)

        for follower in following:
            if follower != answer.created_by:
                class UserReq:
                    user = follower
                context['request'] = UserReq
                notifications.send_notifications(
                    get_topic_by_object(answer),
                    action,
                    answer.__class__.__name__.lower(),
                    follower.uuid,
                    serializer.data)
Пример #15
0
def feeds_fanout_replied(action):
    """Distribute notifications about a comment being replied to."""
    # Fan out notification to parent Comment followers
    for follower in models_actstream.followers(
            action.action_object.parent_comment):
        if action.actor == follower:
            # If the reply author is the same as the parent comment author
            log.debug('Skipping notification generation for comment owner')
            continue
        log.debug('Generating notification for user %i about reply %i' %
                  (follower.id, action.action_object.id))
        follower.feed_entries.create(action=action)
        # Email notification
        content_name = truncatechars(action.action_object.entity.title, 15)
        content_text = truncatechars(action.action_object.content, 25)
        reply_context = dillo.views.emails.CommentOrReplyContext(
            subject='Your comment has a new reply!',
            own_name=follower.profile.first_name_guess or follower.username,
            own_profile_absolute_url=follower.profile.absolute_url,
            action_author_name=action.actor.profile.first_name_guess
            or action.actor.username,
            action_author_absolute_url=action.actor.profile.absolute_url,
            content_name=content_name,
            content_absolute_url=action.action_object.absolute_url,
            content_text=content_text,
        ).as_dict
        send_notification_mail(
            f'Your comment has a new reply!',
            follower,
            template='reply',
            context=reply_context,
        )
Пример #16
0
def send_action_mail(action):
    users = set(filter(lambda x: x.userprofile.notify_by_email,
                       reduce(lambda res, x: (res | set(followers(x))) if x else res,
                              [action.actor, action.action_object, action.target], set())))

    q = None
    if isinstance(action.action_object, Task):
        q = Q(userprofile__notify_about_new_tasks=True)
    if isinstance(action.action_object, Service):
        q = Q(userprofile__notify_about_new_services=True)
    if q:
        users |= set(User.objects.filter(q & Q(userprofile__notify_by_email=True)))

    connection = get_connection(fail_silently=True)
    site = Site.objects.get(pk=1)
    messages = []
    emails = set()
    if hasattr(action.actor, 'email'):
        emails.add(action.actor.email)
    for user in users:
        if user.email in emails:
            continue
        messages.append(create_action_email(
            Context({'action': action, 'user': user, 'site': site}), user.email, connection))
        emails.add(user.email)

    if isinstance(action.action_object, django_comments.get_model()) and action.action_object.parent \
            and not action.action_object.parent.user and action.action_object.parent.email not in emails:
        messages.append(create_action_email(
            Context({'action': action, 'user_name': action.action_object.parent.name, 'site': site}),
            action.action_object.parent.email, connection))

    connection.send_messages(messages)
Пример #17
0
def profile(request, username):
	user = get_object_or_404(User, username__iexact = username)
	if request.is_ajax():
		queryset = Message.objects.get_conversation_between(user, request.user)
		paginator = Paginator(queryset, 10)
		page = request.GET.get('page')
		try:
			message_list = paginator.page(page)
		except PageNotAnInteger:
			raise Http404
		except EmptyPage:
			# If page is out of range (e.g. 9999), deliver last page of results.
			message_list = paginator.page(paginator.num_pages)
		return render_to_response('umessages/conversation.html',{'message_list': message_list})
	else:
		extra_context = dict()
		extra_context['followers'] = ActStream.followers(user)
		extra_context['followings'] = ActStream.following(user)
		extra_context['recipe_list'] = list(user.recipe_set.all().only('name', 'cover_image', 'did_num', 'like_num', 'date', 'view_num'))
		extra_context['favourite_list'] = list(user.get_profile().favourite_recipes.all().only('name', 'cover_image', 'did_num', 'like_num', 'date', 'view_num'))
		extra_context['form'] = MugshotForm()
		extra_context['public_messages'] = list(Message.objects.get_public_messages(to_user = user))
		extra_context['recommends'] = list(recommendations.recommendRecipeForUser(user.id, 10))
		extra_context['did_recipe_list'] = list(DidRecipe.objects.filter(user = user).select_related('recipe').only('image', 'date', 'recipe__name'))
		response = profile_detail(request, username, extra_context = extra_context)

		return response
Пример #18
0
def lireConversation(request, destinataire):
    conversation = getOrCreateConversation(request.user.username, destinataire)
    messages = Message.objects.filter(conversation=conversation).order_by("date_creation")

    message_defaut = None
    id_panier = request.GET.get('panier')
    if id_panier:
        id_destinataire = Profil.objects.get(username=destinataire).id
        message_defaut = Panier.objects.get(id=id_panier).get_message_demande(int(id_destinataire))

    id_produit = request.GET.get('produit')
    if id_produit:
        message_defaut = Produit.objects.get(id=id_produit).get_message_demande()

    form = MessageForm(request.POST or None, message=message_defaut)
    if form.is_valid():
        message = form.save(commit=False)
        message.conversation = conversation
        message.auteur = request.user
        conversation.date_dernierMessage = message.date_creation
        conversation.dernierMessage =  "(" + str(message.auteur) + ") " + str(message.message[:50]) + "..."
        conversation.save()
        message.save()
        url = conversation.get_absolute_url()
        action.send(request.user, verb='envoi_salon_prive', action_object=conversation, url=url, group=destinataire,
                    description="a envoyé un message privé à " + destinataire)
        profil_destinataire = Profil.objects.get(username=destinataire)
        if profil_destinataire in followers(conversation):
            sujet = "Permacat - quelqu'un vous a envoyé une message privé"
            message = request.user.username + " vous a envoyé un message privé. Vous pouvez y accéder en suivant ce lien : http://www.perma.cat" +  url
            send_mail(sujet, message, "*****@*****.**", [profil_destinataire.email, ], fail_silently=False,)
        return redirect(request.path)

    return render(request, 'lireConversation.html', {'conversation': conversation, 'form': form, 'messages_echanges': messages, 'destinataire':destinataire})
Пример #19
0
def on_comment_create(sender, instance, created, **kwargs):
    comment = instance
    if created:
        notify.send(
            comment.user,
            recipient=followers(comment.post),
            verb="wrote a comment",
            action_object=comment,
            target=comment.post,
        )
        notify.send(
            comment.user,
            recipient=followers(comment.user),
            verb="wrote a comment",
            action_object=comment,
        )
Пример #20
0
def profile_related_list(request, username, relation):
    "Render the list of a users folllowers or who the user is following"
    profile = get_object_or_404(Profile, user__username__iexact=username)
    user = profile.user

    # get a queryset of users described by this relationship
    if relation == 'followers':
        related_users = models.followers(user)
    elif relation == 'following':
        related_users = models.following(user)

    paginator = Paginator(related_users, 20)
    page = request.GET.get('page')
    try:
        related_users = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        related_users = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        related_users = paginator.page(paginator.num_pages)
    return render(request, "accounts/account_profile_related.html", {
        'user': user,
        'profile': profile,
        'related_users': related_users,
    })
Пример #21
0
 def get_context_data(self, **kwargs):
     """Adds visible requests and followers to project context"""
     context = super(ProjectDetailView, self).get_context_data(**kwargs)
     project = context['object']
     user = self.request.user
     context['sidebar_admin_url'] = reverse('admin:project_project_change',
                                            args=(project.pk, ))
     context['visible_requests'] = (
         project.requests.get_viewable(user).select_related(
             'agency__jurisdiction__parent__parent',
             'composer__user__profile',
         ).get_public_file_count())
     context['followers'] = followers(project)
     context['articles'] = (
         project.articles.get_published().prefetch_related(
             Prefetch('authors',
                      queryset=User.objects.select_related('profile'))))
     context['contributors'] = project.contributors.select_related(
         'profile')
     context['user_is_experimental'] = user.is_authenticated(
     ) and user.profile.experimental
     context['newsletter_label'] = ('Subscribe to the project newsletter'
                                    if not project.newsletter_label else
                                    project.newsletter_label)
     context['newsletter_cta'] = ('Get updates delivered to your inbox'
                                  if not project.newsletter_cta else
                                  project.newsletter_cta)
     context['user_can_edit'] = project.editable_by(user)
     return context
Пример #22
0
    def get_queryset(self):
        order_by = self.request.GET.get('o')
        order_dir = self.request.GET.get('d')

        # Get ordering field name
        if order_by == 'name':
            order = 'user__first_name'
        else:
            order = 'rank_pts'

        # Get ordering direction (asc/desc)
        if order_dir == 'asc':
            prefix = ''
        else:
            prefix = '-'

        qs = super(UserListView, self).get_queryset().filter(
            user__is_active=True).exclude(user__pk=1)

        # Filter results for single location only
        if self.location is not None:
            qs = qs.filter(
                user__pk__in=[x.pk for x in followers(self.location)])

        # Allow simple search functionality
        search_query = self.request.GET.get('q')
        if search_query is not None:
            qs = qs.filter(Q(user__first_name__icontains=search_query) |
                           Q(user__last_name__icontains=search_query))

        return qs.order_by("{}{}".format(prefix, order))
Пример #23
0
def feeds_fanout_commented(action):
    # Fan out notification to Post followers
    for follower in models_actstream.followers(action.action_object.entity):
        if action.actor == follower:
            log.debug('Skipping notification generation post owner')
            continue
        log.debug('Generating notification for user %i about comment %i' %
                  (follower.id, action.action_object.id))
        follower.feed_entries.create(action=action)
        # Email notification
        content_name = truncatechars(action.action_object.entity.title, 15)
        content_text = truncatechars(action.action_object.content, 25)
        comment_context = dillo.views.emails.CommentOrReplyContext(
            subject='Your post has a new comment!',
            own_name=follower.profile.first_name_guess or follower.username,
            own_profile_absolute_url=follower.profile.absolute_url,
            action_author_name=action.actor.profile.first_name_guess
            or action.actor.username,
            action_author_absolute_url=action.actor.profile.absolute_url,
            content_name=content_name,
            content_absolute_url=action.action_object.absolute_url,
            content_text=content_text,
        ).as_dict

        send_notification_mail(
            f'Your post "{content_name}" has a new comment',
            follower,
            template='comment',
            context=comment_context,
        )
Пример #24
0
    def handle(self, *args, **kwargs):
        user_id = kwargs.get('user_id')
        if not user_id:
            users = User.objects.all()
        else:
            users = User.objects.filter(id=user_id)

        for user in users:
            follower_users = followers(user)
            following_users = following(user, User)

            if follower_users:
                num_followers = len(follower_users)
            else:
                num_followers = 0  # initially default value was None instead of 0, so update the db with 0
            if following_users:
                num_following = len(following_users)
            else:
                num_following = 0

            user.basic_stats.num_followers = num_followers
            user.basic_stats.num_following = num_following
            user.basic_stats.save()

        self.stdout.write('Done!\n')
Пример #25
0
 def user_actions(self, user):
     '''Provides action interfaces for users'''
     is_owner = self.created_by(user)
     can_follow = user.is_authenticated() and not is_owner
     is_following = user in followers(self)
     is_admin = user.is_staff
     kwargs = {
         'jurisdiction': self.jurisdiction.slug,
         'jidx': self.jurisdiction.pk,
         'idx': self.pk,
         'slug': self.slug
     }
     return [
         Action(test=True,
                link=reverse('foia-clone', kwargs=kwargs),
                title='Clone',
                desc='Start a new request using this one as a base',
                class_name='primary'),
         Action(test=can_follow,
                link=reverse('foia-follow', kwargs=kwargs),
                title=('Unfollow' if is_following else 'Follow'),
                class_name=('default' if is_following else 'primary')),
         Action(
             test=self.has_perm(user, 'flag'),
             title='Get Help',
             action='flag',
             desc=
             u'Something broken, buggy, or off?  Let us know and we’ll fix it',
             class_name='failure modal'),
         Action(test=is_admin,
                title='Contact User',
                action='contact_user',
                desc=u'Send this request\'s owner an email',
                class_name='modal'),
     ]
Пример #26
0
def activity(request):
	if request.is_ajax():

		queryset = models.user_stream(request.user)
		paginator = Paginator(queryset, 10)
		page = request.GET.get('page')
		try:
			action_list = paginator.page(page)
		except PageNotAnInteger:
			raise Http404
		except EmptyPage:
			# If page is out of range (e.g. 9999), deliver last page of results.
			action_list = paginator.page(paginator.num_pages)
		return render_to_response('actstream/update_list.html',{
			'action_list': action_list,
		})

	else:
		queryset = models.user_stream(request.user)
		paginator = Paginator(queryset, 10)
		try:
			action_list = paginator.page(1)
		except PageNotAnInteger:
			raise Http404
		except EmptyPage:
			# If page is out of range (e.g. 9999), deliver last page of results.
			action_list = paginator.page(paginator.num_pages)		
		return render(request, 'actstream/update.html', {
					'ctype': ContentType.objects.get_for_model(User),
					'actor': request.user, 
					'action_list': action_list,
					'following': models.following(request.user),
					'followers': models.followers(request.user),
					'recommends': recommendations.recommendRecipeForUser(request.user.id, 10)
			})
Пример #27
0
def profile_related_list(request, username, relation):
    "Render the list of a users folllowers or who the user is following"
    profile = get_object_or_404(Profile, user__username__iexact=username)
    user = profile.user

    # get a queryset of users described by this relationship
    if relation == 'followers':
        related_users = models.followers(user)
    elif relation == 'following':
        related_users = models.following(user)

    paginator = Paginator(related_users, 20)
    page = request.GET.get('page')
    try:
        related_users = paginator.page(page)
    except PageNotAnInteger:
        # If page is not an integer, deliver first page.
        related_users = paginator.page(1)
    except EmptyPage:
        # If page is out of range (e.g. 9999), deliver last page of results.
        related_users = paginator.page(paginator.num_pages)
    return render(request, "accounts/account_profile_related.html", {
        'user': user,
        'profile': profile,
        'related_users': related_users,
    })
Пример #28
0
    def get_queryset(self):
        order_by = self.request.GET.get('o')
        order_dir = self.request.GET.get('d')

        # Get ordering field name
        if order_by == 'name':
            order = 'user__first_name'
        else:
            order = 'rank_pts'

        # Get ordering direction (asc/desc)
        if order_dir == 'asc':
            prefix = ''
        else:
            prefix = '-'

        qs = super(UserListView, self).get_queryset().filter(
            user__is_active=True).exclude(user__pk=1)

        # Filter results for single location only
        if self.location is not None:
            qs = qs.filter(
                user__pk__in=[x.pk for x in followers(self.location)])

        # Allow simple search functionality
        search_query = self.request.GET.get('q')
        if search_query is not None:
            qs = qs.filter(
                Q(user__first_name__icontains=search_query)
                | Q(user__last_name__icontains=search_query))

        return qs.order_by("{}{}".format(prefix, order))
Пример #29
0
 def get_followers(self):
     order = self.request.GET.get('order')
     qs = User.objects.filter(pk__in=[x.pk for x in followers(self.object)])
     if order == 'abc':
         return qs.order_by('first_name', 'last_name')
     else:
         return qs.order_by('-profile__rank_pts')
Пример #30
0
def lireConversation(request, destinataire):
    conversation = getOrCreateConversation(request.user.username, destinataire)
    messages = Message.objects.filter(conversation=conversation).order_by("date_creation")


    form = MessageForm(request.POST or None)
    if form.is_valid():
        message = form.save(commit=False)
        message.conversation = conversation
        message.auteur = request.user
        conversation.date_dernierMessage = message.date_creation
        conversation.dernierMessage =  ("(" + str(message.auteur) + ") " + str(strip_tags(message.message).replace('&nspb',' ')))[:96] + "..."
        conversation.save()
        message.save()
        url = conversation.get_absolute_url()
        action.send(request.user, verb='envoi_salon_prive', action_object=conversation, url=url, group=destinataire,
                    description="a envoyé un message privé à " + destinataire)
        profil_destinataire = Profil.objects.get(username=destinataire)
        if profil_destinataire in followers(conversation):
            sujet = "PacteACVI - quelqu'un vous a envoyé une message privé"
            message = request.user.username + " vous a envoyé un message privé ://pacteacvi.herokuapp.com" +  url
            send_mail(sujet, message, "*****@*****.**", [profil_destinataire.email, ], fail_silently=False,)
        return redirect(request.path)

    return render(request, 'lireConversation.html', {'conversation': conversation, 'form': form, 'messages_echanges': messages, 'destinataire':destinataire})
Пример #31
0
def get_followers_list(request,user_pk):
    """List of users who follow  user_pk"""
    print "getting  followers_list"
    connection = User.objects.get(pk=user_pk)
    cur_user = connection
    node = request.user
    followers_of_user = followers(User.objects.get(pk=user_pk))
    node_follows = following(node)
    followers_list = []
    for connected in followers_of_user:
        if connected in node_follows:
            followers_list.append({"followed_by_connection":connected, "followed_by_me":"Following"})
        else:
            followers_list.append({"followed_by_connection":connected, "followed_by_me":"Not Following"})

    is_cur_user = False
    if  request.user == connection:
        is_cur_user = True

    ctx = {
        "followers_list": followers_list, 
        'cur_user':cur_user,
        'followed_user' : connection.first_name,
        'is_cur_user' :  is_cur_user,
    }

    print 'followers'
    print followers_list
    return render(request,"profile/user_connections.html",ctx)
Пример #32
0
 def get_followers(self):
     order = self.request.GET.get('order')
     qs = User.objects.filter(pk__in=[x.pk for x in followers(self.object)])
     if order == 'abc':
         return qs.order_by('first_name', 'last_name')
     else:
         return qs.order_by('-profile__rank_pts')
Пример #33
0
def articles_suivis(request, slug):
    article = Article.objects.get(slug=slug)
    suiveurs = followers(article)
    return render(request, 'blog/articles_suivis.html', {
        'suiveurs': suiveurs,
        "article": article,
    })
Пример #34
0
def profile(request,id):
     user=User.objects.get(id=id)
     profile=Profile.objects.get(user=user)
     images=Image.objects.filter(user=user)
     following1=following(user)
     followers1=followers(profile)
    
     return render(request, 'grams/profile.html',{"user":user,"profile": profile, 'images':images,'following':following1,'followers':followers1})
Пример #35
0
 def followers(self, request, pk):
     queryset = Profile.objects.all()
     profile = get_object_or_404(queryset, pk=pk)
     user = profile.user
     targets = followers(user)
     profiles = [_.profile for _ in targets]
     serializer = MinimalProfileSerializer(profiles, many=True)
     return Response(serializer.data)
Пример #36
0
def send_notification(sender, instance, created, **kwargs):

    if not created:
        return

    recipients = actstream_models.followers(instance.actor)

    if instance.action_object:
        recipients += actstream_models.followers(instance.action_object)

    if instance.target:
        recipients += actstream_models.followers(instance.target)

    unique_recipients = set(recipients)
    for recipient in unique_recipients:
        n = Notification(recipient=recipient, action=instance)
        n.save()
Пример #37
0
    def to_representation(self, obj):
        return_obj = super(UserSerializer, self).to_representation(obj)
        followers_count = len(followers(obj))
        following_count = len(following(obj))

        new_obj = {"following": following_count, "followers": followers_count}
        return_obj.update(new_obj)
        return return_obj
Пример #38
0
def user_follows(sender, instance, created, **kwargs):
    # Update users counters
    instance.user.profile.total_following =\
        len(following(instance.user, User))
    instance.user.profile.save()

    instance.follow_object.profile.total_followers =\
        len(followers(instance.follow_object))
    instance.follow_object.profile.save()
Пример #39
0
def user_deletes_recipe(sender, instance, using, **kwargs):
    # Update users counters
    instance.user.profile.total_following =\
        len(following(instance.user, User))
    instance.user.profile.save()

    instance.follow_object.profile.total_followers =\
        len(followers(instance.follow_object))
    instance.follow_object.profile.save()
Пример #40
0
 def get_context_data(self, **kwargs):
     context = super().get_context_data(**kwargs)
     tag_name = self.kwargs['tag_name']
     context['tag_name'] = tag_name
     # TODO(fsiddi) Refactor tag_name as tag.name
     context['tag'] = get_object_or_404(Tag, name=tag_name)
     context['tag_followers_count'] = len(followers(context['tag']))
     context['query_url'] = reverse('embed_posts_list_tag', kwargs={'tag_name': tag_name})
     return context
Пример #41
0
def followers(request, content_type_id, object_id):
    """
    Creates a listing of ``User``s that follow the actor defined by
    ``content_type_id``, ``object_id``.
    """
    ctype = get_object_or_404(ContentType, pk=content_type_id)
    actor = get_object_or_404(ctype.model_class(), pk=object_id)
    return render_to_response(('actstream/followers.html', 'activity/followers.html'), {
        'followers': models.followers(actor), 'actor': actor
    }, context_instance=RequestContext(request))
Пример #42
0
    def my_suggestions(self, request):
        # Big method. We'll start with followers, then have follows of follows
        user = request.user
        users_following_me = [u for u in followers(user) if not Follow.objects.is_following(user, u)]
        followers_of_follows = []
        follows_of_follows = []
        # Now look at the users that we're following
        for user_i_follow in following(user):
            for follow_of_follow in following(user_i_follow):
                if follow_of_follow.id != user.id and not Follow.objects.is_following(user, follow_of_follow):
                    follows_of_follows += [follow_of_follow]
            for follower_of_follow in followers(user_i_follow):
                if follower_of_follow.id != user.id and not Follow.objects.is_following(user, follower_of_follow):
                    followers_of_follows += [follower_of_follow]

        target_profiles = set([_.profile for _ in users_following_me + follows_of_follows + followers_of_follows])
        print(target_profiles)
        serializer = MinimalProfileSerializer(target_profiles, many=True)
        return Response(serializer.data)
Пример #43
0
def handle_action(action_id):
    action = Action.objects.get(pk=action_id)
    if action.public:
        users = followers(action.target)
        users = [user for user in users if user_wants_notification(user, action)]
        notifications = [Notification(user=user, action=action) for user in users]

        Notification.objects.bulk_create(notifications)
    else:
        user = action.actor
        Notification.objects.create(user=user, action=action)
Пример #44
0
def followers(request, content_type_id, object_id):
    """
    Creates a listing of ``User``s that follow the actor defined by
    ``content_type_id``, ``object_id``.
    """
    ctype = get_object_or_404(ContentType, pk=content_type_id)
    instance = get_object_or_404(ctype.model_class(), pk=object_id)

    return render(request, 'actstream/followers.html', context={
        'followers': models.followers(instance), 'actor': instance
    })
Пример #45
0
def get_profile(request, profile_name):
    user = get_object_or_404(User, username=profile_name)
    user_d = user_to_dict(get_object_or_404(User, username=profile_name))
    user_d["following"] = following(user)
    user_d["followers"] = followers(user)
    user_d["actions"] = [dict(verb=x.verb,
                              object=x.action_object and user_to_dict(x.action_object),
                              when=int(x.timestamp.strftime("%s")) * 1000,
                              data=x.data)
                         for x in actor_stream(user)[:3]]
    return user_d
Пример #46
0
    def post(self, request, username, format=None):
        user_to_follow = get_object_or_404(User, username=username)
        following_list = following(request.user, User)
        if user_to_follow in following_list:
            unfollow(request.user, user_to_follow)
            data = {'message': 'User unfollowed successfully'}
        else:
            follow(request.user, user_to_follow)
            data = {'message': 'User followed successfully'}

        data['count'] = len(followers(user_to_follow))
        return Response(data)
Пример #47
0
def comment_action(sender, comment=None, target=None, **kwargs):
    action.send(comment.user, verb=u'commented', action_object=comment, 
            target=comment.content_object)
    target = comment.content_object
    
    from actstream.models import followers

    notify_list = followers(target)
    if hasattr(target, 'user'):
       notify_list.append(target.user)
    notification.send(notify_list, "comment_added", 
        { "comment": comment.text, "commenter": comment.user, "target": target })
def followers(request, content_type_id, object_id):
    """
    Creates a listing of ``User``s that follow the actor defined by
    ``content_type_id``, ``object_id``.
    """
    ctype = get_object_or_404(ContentType, pk=content_type_id)
    instance = get_object_or_404(ctype.model_class(), pk=object_id)
    return render_to_response(
        "actstream/followers.html",
        {"followers": models.followers(instance), "actor": instance},
        context_instance=RequestContext(request),
    )
    def test_followers_following(self):
        response = self.get('actstream_followers', self.user_ct.pk, self.user2.pk)
        self.assertTemplateUsed(response, 'actstream/followers.html')
        self.assertEqual(response.context['user'], self.user1)
        self.assertQSEqual(response.context['followers'],
                           models.followers(self.user2))

        response = self.get('actstream_following', self.user2.pk)
        self.assertTemplateUsed(response, 'actstream/following.html')
        self.assertEqual(response.context['user'], self.user2)
        self.assertQSEqual(response.context['following'],
                           models.following(self.user2))
Пример #50
0
def followers(request, content_type_id, object_id):
    """
    Creates a listing of ``User``s that follow the actor defined by
    ``content_type_id``, ``object_id``.
    """
    if request.user.is_authenticated():
        ctype = get_object_or_404(ContentType, pk=content_type_id)
        actor = get_object_or_404(ctype.model_class(), pk=object_id)
        return render_to_response('social/followers.html', {
            'followers': models.followers(actor), 'actor': actor
        }, context_instance=RequestContext(request))
    else:
        return redirect("/accounts/login/?next=/")
Пример #51
0
def following(request, user_id):
    """
    Returns a list of actors that the user identified by ``user_id`` is following (eg who im following).
    """
    if request.user.is_authenticated():
        user = get_object_or_404(User, pk=user_id)
        return render_to_response('social/following.html', {
            'following': models.following(user), 
            'followers': models.followers(user),
            'user': user
        }, context_instance=RequestContext(request))
    else:
        return redirect("/accounts/login/?next=/")
Пример #52
0
def user_followers_delete_handler(sender, instance, **kwargs):
    """
    Make all users unfollow the user being deleted.
    N.B. Because django-activity-stream is using a GFK, these do not cascade
    delete.
    """
    # Import act_models here. If imported at the top, this interferes with
    # appconf imports and breaks compressor configuration.
    # See https://github.com/jezdez/django_compressor/issues/333
    from actstream import models as act_models

    followers = act_models.followers(instance)
    for follower in followers:
        unfollow(follower, instance)
Пример #53
0
def user(request, username, active_tab='activity'):
    user_to_show = get_object_or_404(User, username=username)

    # If edit tab is requested, check whether user should have access
    if (active_tab == 'edit') and (request.user.id != user.id):
        return redirect('users:user', username = username)

    context = {
        'active_page': '',
        'active_tab': active_tab,
        'user_to_show': user_to_show,
        'following': following(user_to_show),
        'followers': followers(user_to_show),
        }
    return render(request, "user.html", context)
Пример #54
0
def activity_count(obj):
    """
    Increments the activity stream counter of the followers of the given object
    to make a Facebook look and feel on the top bar.
    """
    from actstream.models import followers

    if not obj:
        return 0
    for user in followers(obj):
        name = 'user_%d_activity_counter' % user.id
        count = get_option(name)
        try:
            count = int(count)
        except:
            count = 0
        update_option(name, count+1)
Пример #55
0
def profile_related_list(request, username, relation):
    "Render the list of a users folllowers or who the user is following"
    profile = get_object_or_404(Profile, user__username__iexact=username)
    if profile.user.username != username:
        return redirect(profile, permanent=True)
    user = profile.user

    # get a queryset of users described by this relationship
    if relation == 'followers':
        related_users = models.followers(user)
    elif relation == 'following':
        related_users = models.following(user)
    return render(request, "accounts/account_profile_related.html", {
        'user': user,
        'profile': profile,
        'related_users': related_users,
    })
Пример #56
0
def profile(request, username=None):
    """
    User profile page.
    """
    user = User.objects.get(username__exact=username)
    profile = user.get_profile()
    form = CellarItemForm()
    follow_state = request.user.is_authenticated() and user in following(request.user)
    context = {
        'this_user': user,
        'username': user.username,
        'email': user.email,
        'cellar': list(profile.cellar.all()),
        'wants': list(profile.wants.all()),
        'form': form,
        'activity': actor_stream(user),
        'friends_activity': user_stream(user),
        'following': following(user),
        'followers': followers(user),
        'follow_state': follow_state,
    }
    return render(request, 'users/profile.html', context)
Пример #57
0
 def followers(self):
     return followers(self.user)
Пример #58
0
 def test_followers(self):
     self.assertEqual(list(followers(self.group)), [self.user2])