Beispiel #1
0
 def decline_invite(self, secret):
     """
     Changes invite status to declined
     """
     if self.single_use:
         self.status = "DECLINED"
         action.send(self.contact, verb='declined invite to', action_object=self.meal)
Beispiel #2
0
    def save(self, *args, **kwargs):

        if self.pk is None:
            target = self.issue.number
            action.send(self.user, verb='placed a $' + str(self.price) + ' bounty on ', target=self.issue)

        super(Bounty, self).save(*args, **kwargs)
Beispiel #3
0
def join_quit_game(request):
	#userID = request.user.id
	response = ''
	if request.method == 'POST': 
		game_id = request.POST['game_id']
		print game_id
		
		game = Game.objects.get(id=game_id)
		if request.user in game.users.all():
			game.users.remove(request.user)
			response = 'left'
			verb = request.user.first_name+' '+request.user.last_name+' left '+game.name
			description = '/game/'+str(game.id)
			notify.send(request.user,recipient=game.creator, verb=verb, description=description)
			action.send(request.user, verb="leave game", action_object=game)
		else:
			game.users.add(request.user)
			response = 'joined'
			verb = request.user.first_name+' '+request.user.last_name+' joined '+game.name
			description = '/game/'+str(game.id)
			notify.send(request.user,recipient=game.creator, verb=verb, description=description)
			action.send(request.user, verb="join game", action_object=game)
	
	#return HttpResponse(response)
	return redirect(request.META['HTTP_REFERER'])
Beispiel #4
0
def task_action(user, task, verb):
    """
    A general action that contains tasks. Here we form whole send orders
    of a given action. A django.contrib.auth.models.User, projects.models.Task
    and verb instance needs to be passed to the function.
    """
    action.send(user, verb=verb, action_object=task, target=task.group.project)
Beispiel #5
0
def edit_message(request, pk):
    message = get_object_or_404(Message, pk=pk)
    thread = message.thread

    if not request.user.write_perm(obj=message):
        return HttpResponse('You may not edit this message.', status=403)

    if request.method == 'POST':
        form = MessageForm(request.POST)

        if form.is_valid():
            message.text = form.cleaned_data['content']
            message.save()

            actions.follow(request.user, thread, actor_only=False)
            action.send(request.user, verb="a édité", action_object=message, target=thread)

            return HttpResponseRedirect(reverse('thread_show', args=[thread.id]) + "#message-" + str(message.id))
    else:
        form = MessageForm({'content': message.text})

    return render(request, 'telepathy/edit_message.html', {
        'form': form,
        'thread': thread,
        'edited_message': message,
        'edit': True,
    })
Beispiel #6
0
 def create(self, request):
     if self.check_valid_vote(self.request.user, self.request.POST['comment']):
         vote = CommentVote(vote=True if self.request.POST.get('vote') == 'up' else False,
                            user=self.request.user,
                            date_voted = timezone.now(),
                            comment=CustomComment.objects.get(pk=self.request.POST['comment']))
         vote.save()
         action.send(
             request.user,
             action_object=vote.comment,
             verb= _(u"voted on"),
             vote = True if request.POST.get('vote') == 'up' else False
         )
         suff = "up" if vote.vote else "down"
         notify(
             request.user,
             vote.comment.user,
             action_object=vote,
             action_target=vote.comment,
             verb=_(u"voted {} for your comment".format(suff)),
             key="vote"
         )
         return Response({
             'success': True,
             'message': _('Vote saved')
         })
     else:
         return Response({
             'success': False,
             'message': _('Already voted on this comment')
         })
Beispiel #7
0
def user_logged_out(user, **kwargs):
    """
    receive signals when user logout
    """
    logout_actor = Actor.objects.get(user=user)
    logout_activity = Verb.objects.get(name='logout')
    action.send(logout_actor, verb=logout_activity, description=logout_activity.description)
Beispiel #8
0
 def form_valid(self, form, **kwargs):
     location = form.cleaned_data['location']
     username = location.slug
     create_gallery(username)
     filepath = os.path.join(settings.MEDIA_ROOT, username)
     image = Image.open(form.cleaned_data['image'])
     filename = gallery_item_name()
     width, height = image.size
     if width > settings.IMAGE_MAX_SIZE[0] or height > settings.IMAGE_MAX_SIZE[1]:
         image.thumbnail(settings.IMAGE_MAX_SIZE)
     image.save(os.path.join(filepath, filename), "JPEG")
     create_gallery_thumbnail(username, filename)
     
     item = LocationGalleryItem(
         user = self.request.user,
         picture_name = filename,
         name = form.cleaned_data['name'],
         description = form.cleaned_data['description'],
         location = location
     )
     item.save()
     action.send(
         self.request.user,
         action_object = item,
         target = item.location,
         verb = _('uploaded')
     )
     self.request.user.profile.rank_pts += 2
     self.request.user.profile.save()
     return redirect(reverse('locations:gallery', kwargs={'slug':location.slug}))
Beispiel #9
0
	def form_valid(self, form):

		user = self.request.user
		blog_posts = BlogPost.objects.published(for_user=user).select_related().filter(user=user)
		if blog_posts and blog_posts[0]:
			blog_post = blog_posts[0]

			if blog_post.num_images < getattr(settings, 'MAX_IMAGES_PER_VENDOR', 10):
				blog_post.num_images += 1
				blog_post.save()
				self.object = form.save(commit=False)
				
				if self.object.album.images.exists():
					self.object.order = self.object.album.images.all().aggregate(Max('order'))['order__max'] + 1 #self.object.album.images.all().count()
				else:
					self.object.order = 0
				
				self.object.user = self.request.user
				self.object.save()
				
				if self.object.album:
					self.object.album.save()
					
					if self.object.album.images.all().count() == 1:
						action.send(blog_post, verb=settings.ALBUM_ADD_VERB, target=self.object.album)
					else:
						ctype = ContentType.objects.get_for_model(blog_post)
						target_content_type = ContentType.objects.get_for_model(self.object.album)
						Action.objects.all().filter(actor_content_type=ctype, actor_object_id=blog_post.id, verb=settings.ALBUM_ADD_IMAGE_VERB, target_content_type=target_content_type, target_object_id=self.object.album.id ).delete()
						action.send(blog_post, verb=settings.ALBUM_ADD_IMAGE_VERB, target=self.object.album)
				return HttpResponseRedirect(self.get_success_url())
			else:    
				return json_error_response("'%s' has crossed maximum limit of images" % user)
Beispiel #10
0
def comment(request, template="generic/comments.html"):
    """
    Handle a ``ReviewForm`` submission and redirect back to its
    related object.
    """
    response = initial_validation(request, "comment")
    if isinstance(response, HttpResponse):
        return response
    obj, post_data = response
    form = ReviewForm(request, obj, request.POST )
    if form.is_valid():
        url = obj.get_absolute_url()
        if is_spam(request, form, url):
            return redirect(url)
        comment = form.save(request)
        response = redirect(add_cache_bypass(comment.get_absolute_url()))
        # Store commenter's details in a cookie for 90 days.
        for field in ReviewForm.cookie_fields:
            cookie_name = ReviewForm.cookie_prefix + field
            cookie_value = post_data.get(field, "")
            set_cookie(response, cookie_name, cookie_value)
        """
            Send activity feed to those who follow this vendor page.
        """
        if request.user.is_authenticated():
            action.send(obj, verb=settings.GOT_REVIEW_VERB, target=comment )
        return response
    elif request.is_ajax() and form.errors:
        return HttpResponse(dumps({"errors": form.errors}))
    # Show errors with stand-alone comment form.
    context = {"obj": obj, "posted_comment_form": form}
    response = render(request, template, context)
    return response
Beispiel #11
0
def create_game(request):
	if request.method == 'POST':
		form = GameForm(request.POST)
		if form.is_valid():
			sport = form.cleaned_data['sport']
			name = form.cleaned_data['name']
			cap = form.cleaned_data['cap']
			description = form.cleaned_data['description']
			location_name = form.cleaned_data['location']
			location = Location.objects.get(name=location_name)

			#Need to handle time zones
			datetimeStart = request.POST['dtp_input1']

			sportObj = Sport.objects.get(name=sport.lower())
			newGame = Game.objects.create(sport=sportObj,name=name,timeStart=datetimeStart, creator=request.user, location=location, cap=cap, description=description)
			newGame.dateCreated = datetime.datetime.now()
			newGame.users.add(request.user)
	
			newGame.save()
			action.send(request.user,verb="game created",action_object=newGame)
			return redirect('/game/'+str(newGame.id))
		else:
			print 'invalid form'
			error_msg = 'Could not create your game. Please try again!'
			return render(request, 'create_game.html', {'gameForm':form, 'error_msg':error_msg})
	else:
		gameForm = GameForm()
		return render(request, 'create_game.html', {'gameForm':gameForm})
Beispiel #12
0
def handle_cm_save(sender, created, instance, **kwargs):
    cmct = ContentType.objects.get(app_label="committees", model="committeemeeting")
    mct = ContentType.objects.get(app_label="mks", model="member")
    for m in instance.mks_attended.all():
        if Action.objects.filter(actor_object_id=m.id, actor_content_type=mct, verb='attended', target_object_id=instance.id, 
                target_content_type=cmct).count()==0:    
            action.send(m, verb='attended', target=instance, description='committee meeting', timestamp=instance.date)
Beispiel #13
0
def report(request, lot_number):
    report = Report.objects.get(lot_number=lot_number)
    audit_log = target_stream(report)
    orders = OrderLineItem.objects.filter(report=report)
    newdoc = NewDocumentForm(None)

    if 'document_button' in request.POST:
        newdoc = NewDocumentForm(request.POST, request.FILES)
        if newdoc.is_valid():
            doc = Document(type=newdoc.cleaned_data['type'],
                           file=request.FILES['file'], created_by=request.user)
            doc.save()
            action.send(request.user, verb="created document", action_object=doc)
            rd = ReportDocument(report=report, document=doc, primary_document=newdoc.cleaned_data['primary'], created_by=request.user, internal_cert=newdoc.cleaned_data['internal'])
            rd.save()
            action.send(request.user, verb="attached document", action_object=rd, target=report)
            report.save()
            messages.success(request, 'Document upload successful.')

            return HttpResponseRedirect(reverse('reports.views.report',
                                                    args=[report.lot_number]))
	
	
    return render_to_response('reports/report.html', 
                              {
                                  'report': report,
                                  'new_document_form': newdoc,
                                  'orders': orders,
                                  'audit_log': audit_log,
                              },
                              context_instance=RequestContext(request))
Beispiel #14
0
def issue_beercoin(request):
    owner = get_object_or_404(User, username=request.GET.get("owner"))
    comment = request.GET.get("comment", None)
    what_for = request.GET.get("what_for", None)
    issuer = request.user

    if issuer.username == owner.username:
        raise BeerCoinTransactionError("You can't owe beers yourself")

    if issuer.profile.balance <= -10:
        raise BeerCoinTransactionError("You already owe a lot. Not acceptable.")   # fixme: make better

    owner.profile.balance += 1
    issuer.profile.balance -= 1

    owner.profile.save()
    issuer.profile.save()

    action.send(issuer, verb="issued", action_object=owner,
            comment=comment, what_for=what_for)

    if owner.profile.balance == -10:
        action.send(issuer, verb="reached limit")

    return {"success": True}
Beispiel #15
0
def project_create_edit(request, project_slug=None):
    user = request.user
    site = Site.objects.get(id=current_site_id)
    if project_slug:
        project = get_object_or_404(Project, slug=project_slug)
    else:
        project = Project(user=user, site=site)
    if not project.is_editable(request):
        return HttpResponseForbidden('You are not the owner of this project.')
    project_form = ProjectForm(
        request.POST or None, request.FILES or None, instance=project
    )
    if project_form.is_valid():
        project_form.save()
        if project.is_published():
            action.send(user, verb='updated', target=project)
        if 'save-add-step' in request.POST:
            redirect_args = ('project-step-create-edit', project.slug)
        else:
            redirect_args = (project,)
        return redirect(*redirect_args)
    return render(request, 'project/project_create_edit.html', {
        'project': project,
        'project_form': project_form,
    })
Beispiel #16
0
def dashboard_import(request):
    if request.user.is_authenticated():
        if request.method == 'POST':
            import_project_form = ImportProjectForm(request.POST, request=request)
            if import_project_form.is_valid():
                project_cleaned = import_project_form.cleaned_data
                user = HubUser.objects.get(user__username__iexact=request.user.username)
                github_request = urllib2.urlopen('https://api.github.com/repos/%s/%s' % (user.github, project_cleaned['name']))
                json_data = json.loads(github_request.read())
               
                new_project = Project.objects.create(name=project_cleaned['name'],
                                                    status=project_cleaned['status'],
                                                    descript=json_data['description'],
                                                    language=json_data['language'],
                                                    version='1.0',
                                                    created_on=json_data['created_at'],
                                                    url=json_data['url'],
                                                    )
                
                user = HubUser.objects.get(user__username__iexact=request.user.username)
                new_project.owners.add(user)
                new_project.save()
                Forum(project=new_project).save()
                action.send(request.user, verb="Added a project.")
                return HttpResponseRedirect("/dashboard")
            else:
                return render(request, 'dashboard_import.html', {'import_project_form': import_project_form})
        else:
            import_project_form = ImportProjectForm(request=request)
            return render(request, 'dashboard_import.html', {'import_project_form': import_project_form})
    else:
        return HttpResponseRedirect("/login")
Beispiel #17
0
def toggleproperty_post_save(sender, instance, created, **kwargs):
    if created:
        if instance.property_type in ("like", "bookmark"):
            if instance.property_type == "like":
                verb = "likes"
            elif instance.property_type == "bookmark":
                verb = "bookmarked"

            if instance.content_type == ContentType.objects.get_for_model(Image):
                image = instance.content_type.get_object_for_this_type(id = instance.object_id)
                if image.is_wip:
                    return

            act.send(instance.user, verb = verb, target = instance.content_object)

            if instance.content_type == ContentType.objects.get_for_model(Image):
                push_notification(
                    [instance.content_object.user], 'new_' + instance.property_type,
                    {
                        'url': settings.ASTROBIN_BASE_URL + instance.content_object.get_absolute_url(),
                        'user': instance.user.userprofile,
                    })

        elif instance.property_type == "follow":
            user_ct = ContentType.objects.get_for_model(User)
            if instance.content_type == user_ct:
                followed_user = user_ct.get_object_for_this_type(pk = instance.object_id)
                push_notification([followed_user], 'new_follower',
                                  {'object': instance.user.userprofile,
                                   'object_url': instance.user.get_absolute_url()})
Beispiel #18
0
def vote(request):
    """ Make vote (up/down) on idea. """
    if request.method == 'POST':
        idea = Idea.objects.get(pk=request.POST['idea'])
        votes_check = Vote.objects.filter(user=request.user).filter(idea=idea)
        if len(votes_check) > 0:
            response = {
                'success': False,
                'message': _('You voted already on this idea'),
                'votes': idea.get_votes(),
            }
        else:
            user_vote = Vote(
                user = request.user,
                idea = idea,
                vote = True if request.POST.get('vote') == 'up' else False
            )
            user_vote.save()
            response = {
                'success': True,
                'message': _('Vote saved'),
                'votes': idea.get_votes(),
            }
            action.send(
                request.user,
                action_object=user_vote,
                target=user_vote.idea,
                verb= _('voted on'),
                vote = True if request.POST.get('vote') == 'up' else False
            )
            request.user.profile.rank_pts += 1
            request.user.profile.save()
        return HttpResponse(json.dumps(response), content_type="application/json")
Beispiel #19
0
def RegisterUser(request):
    if request.method == 'POST':
        mainuser_form = MainUserForm(request.POST)
        hubuser_form = HubUserForm(request.POST)

        if mainuser_form.is_valid() and hubuser_form.is_valid():
            user_cd = mainuser_form.cleaned_data
            new_user = User.objects.create_user(username=user_cd['username'],
                                                password=user_cd['password'],
                                                first_name=user_cd['first_name'],
                                                last_name=user_cd['last_name'])
            new_hubuser = hubuser_form.save(commit=False)
            new_hubuser.user = new_user
            new_hubuser.save()
            user = authenticate(username=user_cd['username'],
                                password=user_cd['password'])
            if user is not None:
                if user.is_active:
                    login(request, user)
                    action.send(request.user, verb="Joined Coderzhub.")
                    return HttpResponseRedirect("/dashboard")
    else:
        mainuser_form = MainUserForm()
        hubuser_form = HubUserForm()
    return render(request, 'register.html', {'mainuser_form': mainuser_form,
                                             'hubuser_form': hubuser_form})
Beispiel #20
0
 def _handle_bill_update(self, cm, request):
     bill_id = request.POST.get('bill_id')
     if not bill_id:
         raise Http404()
     if bill_id.isdigit():
         bill = get_object_or_404(Bill, pk=bill_id)
     else:  # not a number, maybe its p/1234
         m = re.findall('\d+', bill_id)
         if len(m) != 1:
             raise ValueError(
                 "didn't find exactly 1 number in bill_id=%s" % bill_id)
         pp = PrivateProposal.objects.get(proposal_id=m[0])
         bill = pp.bill
     if bill.stage in ['1', '2', '-2',
                       '3']:  # this bill is in early stage, so cm must be one of the first meetings
         bill.first_committee_meetings.add(cm)
     else:  # this bill is in later stages
         v = bill.first_vote  # look for first vote
         if v and v.time.date() < cm.date:  # and check if the cm is after it,
             bill.second_committee_meetings.add(
                 cm)  # if so, this is a second committee meeting
         else:  # otherwise, assume its first cms.
             bill.first_committee_meetings.add(cm)
     bill.update_stage()
     action.send(request.user, verb='added-bill-to-cm',
                 description=cm,
                 target=bill,
                 timestamp=datetime.datetime.now())
Beispiel #21
0
def series_new(request):
    """ A logged in user can create a series.

    Series serve as a linking mechanism to connect related stories and to share
    assets between them. Series allow users to create planning notes at a series level
    have planning discussions and upload assets. Assets are always associated with a series
    so they are easily accessible to stories and all facets. This means that even single
    stories technically have a series, but in that case the user does not interact with any
    series interface.
    """

    seriesform = SeriesForm(request=request)
    if request.method == "POST":
        seriesform = SeriesForm(request.POST, request=request)
    if seriesform.is_valid():
        series = seriesform.save(commit=False)
        series.owner = request.user
        series.organization = request.user.organization
        series.creation_date = timezone.now()
        discussion = Discussion.objects.create_discussion("SER")
        series.discussion = discussion
        series.save()
        seriesform.save_m2m()

        # record action for activity stream
        action.send(request.user, verb="created", action_object=series)

        return redirect('series_detail', pk=series.pk)
    else:
        seriesform = SeriesForm(request=request)
    return render(request, 'editorial/seriesnew.html', {'seriesform': seriesform})
Beispiel #22
0
    def post(self, request, **kwargs):

        object_id = kwargs['pk']
        if not object_id:
            return HttpResponseBadRequest()


        vote = None
        bill = get_object_or_404(Bill, pk=object_id)
        user_input_type = request.POST.get('user_input_type')
        if user_input_type == 'approval vote':
            vote = Vote.objects.get(pk=request.POST.get('vote_id'))
            bill.approval_vote = vote
            bill.update_stage()
        if user_input_type == 'first vote':
            vote = Vote.objects.get(pk=request.POST.get('vote_id'))
            bill.first_vote = vote
            bill.update_stage()
        if user_input_type == 'pre vote':
            vote = Vote.objects.get(pk=request.POST.get('vote_id'))
            bill.pre_votes.add(vote)
            bill.update_stage()

        action.send(request.user, verb='added-vote-to-bill',
                description=vote,
                target=bill,
                timestamp=datetime.datetime.now())
        return HttpResponseRedirect(".")
 def create_action(self, record):
     try:
         action.send(record.added_by, verb='recorded', action_object=record,
                     target=record.garden, timestamp=record.added)
     except AttributeError:
         # Record is missing some attributes. Skip it.
         pass
Beispiel #24
0
 def post(self, request, pk):
     """ Send message to selected users. """
     users = request.POST.getlist('user[]')
     if users:
         for u in users:
             user = User.objects.get(pk=u)
             translation.activate(user.profile.lang)
             # Send email
             email = mails.InviteUsersMail()
             email.send(user.email, {
                 'inviting_user': request.user,
                 'location': self.get_object(pk),
             })
             # Record action for actstream
             action.send(
                 request.user,
                 action_object = self.get_object(pk),
                 target = user,
                 verb = _("invited you to follow")
             )
         ctx = {
             'success': True,
             'message': _("Successfully send invitation"),
             'level'  : 'success',
         }
     else:
         ctx = {
             'success': False,
             'message': _("User field cannot be empty"),
             'level'  : 'danger',
         }
     return HttpResponse(json.dumps(ctx))
Beispiel #25
0
def handle_annotation_save(sender, created, instance, **kwargs):
    if created:
        action.send(instance.content_object.meeting, verb='annotation-added',
                    target=instance, description=unicode(instance.flag_value))
        action.send(instance.user, verb='annotated',
                    target=instance, description=unicode(instance.flag_value))
        follow(instance.user, instance.content_object.meeting)
Beispiel #26
0
def on_comment_posted(sender, comment, request, **kwargs):

    """
    rs = redis.StrictRedis()
    opt = dict(size=(70, 70), crop=True, bw=True, quality=80)
    try:
        image = get_thumbnailer(request.user.profile_set.all()[0].image).get_thumbnail(opt).url
    except:
        image = None
    message = {
               'user': request.user.username,
               'image': image,
               'comment': comment.comment,
               'comment_html': re.sub('<[^<]+?>', '', comment.comment).replace('\n','<br>\n'),
               'route': comment.content_object.get_api_url(),
               'type': 'message'
               #'timestamp': comment.submit_date
               }
    
    rs.publish('push_chat', json.dumps(message))
    """
    
    from actstream import action
    action.send(request.user, verb='commented on', target=comment.content_object)

    from pushy.util import pushy_custom
    body = {
            'comment': comment.comment,
            'user': request.user.username
            }
    pushy_custom(comment.content_object.uuid, body=body, type='update')
    
    
    """
    Send email notification of a new comment to site staff when email notifications have been requested.
    """
    # This code is copied from django.contrib.comments.moderation.
    # That code doesn't offer a RequestContext, which makes it really
    # hard to generate proper URL's with FQDN in the email
    #
    # Instead of implementing this feature in the moderator class, the signal is used instead
    # so the notification feature works regardless of a manual moderator.register() call in the project.
    if not appsettings.FLUENT_COMMENTS_USE_EMAIL_NOTIFICATION:
        return
    
    return

    recipient_list = [manager_tuple[1] for manager_tuple in settings.MANAGERS]
    site = get_current_site(request)
    content_object = comment.content_object

    subject = '[{0}] New comment posted on "{1}"'.format(site.name, content_object)
    context = {
        'site': site,
        'comment': comment,
        'content_object': content_object
    }

    message = render(request, "comments/comment_notification_email.txt", context)
    send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, recipient_list, fail_silently=True)
Beispiel #27
0
def project_step_create_edit(request, project_slug, project_step_number=None):
    user = request.user
    project = get_object_or_404(Project, slug=project_slug)
    if not project.is_editable(request):
        return HttpResponseForbidden('You are not the owner of this project.')
    if 'add' in request.path and project.steps.count() >= 20:
        messages.add_message(request, messages.WARNING,
                    'This project already contains 20 steps.')
        return redirect('project-detail', project.slug)
    if project_step_number is not None:
        project_step = get_object_or_404(
            ProjectStep, project=project, _order=project_step_number
        )
    else:
        project_step = ProjectStep(project=project)
    project_step_form = ProjectStepForm(
        request.POST or None, instance=project_step
    )
    if project_step_form.is_valid():
        project_step_form.save()
        if project.is_published():
            action.send(user, verb='updated', action_object=project_step, target=project)
        # User clicked "save and add another"
        if 'save-add' in request.POST:
            redirect_args = ('project-step-create-edit', project.slug)
        # User clicked "save" (catch anything else)
        else:
            redirect_args = (project,)
        return redirect(*redirect_args)
    return render(request, 'project/project_step_create_edit.html', {
        'project': project,
        'project_step': project_step,
        'project_step_form': project_step_form,
    })
Beispiel #28
0
    def POST(self, object_id, **kwargs):
        vote = None
        bill = get_object_or_404(Bill, pk=object_id)
        user_input_type = self.request.POST.get("user_input_type")
        if user_input_type == "approval vote":
            vote = Vote.objects.get(pk=self.request.POST.get("vote_id"))
            bill.approval_vote = vote
            bill.update_stage()
        if user_input_type == "first vote":
            vote = Vote.objects.get(pk=self.request.POST.get("vote_id"))
            bill.first_vote = vote
            bill.update_stage()
        if user_input_type == "pre vote":
            vote = Vote.objects.get(pk=self.request.POST.get("vote_id"))
            bill.pre_votes.add(vote)
            bill.update_stage()

        action.send(
            self.request.user,
            verb="added-vote-to-bill",
            description=vote,
            target=bill,
            timestamp=datetime.datetime.now(),
        )
        return HttpResponseRedirect(".")
Beispiel #29
0
 def accept_invite(self, secret, user):
     """
     Checks a secret and allows an invitee to become a guest if it is valid and they are logged in somehow.
     """
     if self.check_secret(secret):
         # Secret matches
         if self.status == "INVITED" or not self.single_use:
             # If the code is not used or can be used multiple times then continue.
             # If the user has an email or a facebook we should try and match it to a profile perhaps.
             if user:
                 # We have a user
                 print user
                 if self.meal.add_guest(user, self, self.plusones):
                     # We have allocated the space at the table
                     # Set status to accepted
                     self.status = "ACCEPTED"
                     self.save()
                     action.send(self.invitee, verb='accepted invite to', action_object=self.meal)
                     # We should save any other info we have about the user to the user profile for display
                 else:
                     # There is not space at the table, we could try with less plusones in future
                     pass
             else:
                 # No user (not even a lazy one!)
                 pass
     else:
         # The secret doesn't match
         print("Bad secret")
         print self.secret
         print secret
     pass
Beispiel #30
0
def comment_action_hook(sender, instance, created, **kwargs):
    """
    Action hook for comments - inform other people about the fact that
    this comment was created and increase the amount of user points
    accordingly.
    """
    if not created:
        return True
    prof = UserProfile.objects.get(user=instance.user)
    prof.rank_pts += 3
    prof.save()
    # Send action for user and location activity streams
    action.send(
        instance.user,
        action_object = instance,
        target = instance.content_object,
        verb = _(u"commented"),
        comment = instance.comment,
        comment_url = instance.content_object.get_absolute_url()
    )
    # Send notification to parent comment author (if this is answer for comment)
    if instance.parent is not None:
        notify(
            instance.user,
            instance.parent.user,
            key="customcomment",
            verb=_(u"answered your comment"),
            action_object=instance,
            action_target=instance.parent
        )
Beispiel #31
0
    def form_valid(self, form):
        workflow = self.object
        if workflow.closed:
            messages.error(self.request,
                           u"You can't add tasks to a closed workflow.")
            return redirect(self.get_success_url())

        workflow.updated_by_user = self.request.user
        workflow.tasks.add(*(form.cleaned_data['tasks']))

        for task in form.cleaned_data['tasks']:
            action.send(workflow.updated_by_user,
                        verb='added',
                        action_object=task,
                        target=workflow,
                        place_code=workflow.place.place_code)

        messages.success(
            self.request, u"Added %d tasks to this workflow." %
            len(form.cleaned_data['tasks']))

        return redirect(self.get_success_url())
Beispiel #32
0
def lireArticle(request, slug):
    article = get_object_or_404(Article, slug=slug)
    if not article.estPublic and not request.user.is_permacat:
        return render(
            request,
            'notPermacat.html',
        )

    commentaires = Commentaire.objects.filter(
        article=article).order_by("date_creation")

    form = CommentForm(request.POST or None)
    if form.is_valid():
        comment = form.save(commit=False)
        comment.article = article
        comment.auteur_comm = request.user
        article.date_dernierMessage = comment.date_creation
        article.dernierMessage = ("(" + str(comment.auteur_comm) + ") " +
                                  str(comment.commentaire))[:96] + "..."
        article.save()
        comment.save()
        url = article.get_absolute_url()
        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
        },
    )
Beispiel #33
0
def reference_add(request, pk, slug, reference_pk, edit=False):
    project = get_object_or_404(Project, pk=pk, slug=slug)
    reference = get_object_or_404(Reference, pk=reference_pk)
    with transaction.atomic():
        project_reference, created = ProjectReference.objects.get_or_create(
            reference=reference, project=project, defaults={'owner': request.user}
        )
        if created:
            action.send(request.user, verb='added', action_object=project_reference, target=project)
            messages.success(
                request,
                'Reference added successfully! If you are finished adding references, '
                'you can return to the <a href="{}">bibliography list</a>.'.format(project.get_bibliography_url()))
        else:
            messages.info(request, "The reference you selected was already added to this project by {}.".format(
                project_reference.owner.get_full_name()))
        if request.is_ajax():
            context = {
                'messages': render_to_string('bootstrap3/messages.html', {}, request=request),
            }
            return JsonResponse(context)
    return redirect(project.get_bibliography_url())
Beispiel #34
0
def post_save_work(sender, instance, **kwargs):
    """ Cascade changes to linked documents
    """
    if not kwargs['raw'] and not kwargs['created']:
        # cascade updates to ensure documents
        # pick up changes to inherited attributes
        for doc in instance.document_set.all():
            # forces call to doc.copy_attributes()
            doc.updated_by_user = instance.updated_by_user
            doc.save()

    # Send action to activity stream, as 'created' if a new work
    if kwargs['created']:
        action.send(instance.created_by_user,
                    verb='created',
                    action_object=instance,
                    place_code=instance.place.place_code)
    else:
        action.send(instance.updated_by_user,
                    verb='updated',
                    action_object=instance,
                    place_code=instance.place.place_code)
Beispiel #35
0
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        profile, created = UserProfile.objects.get_or_create(user=instance)

        comment_flag_ct = ContentType.objects.get_for_model(CommentFlag)
        comment_flag_permissions = Permission.objects.filter(
            content_type=comment_flag_ct)

        action.send(instance, verb='joined framebuzz')

        try:
            # Start following framebuzz, and framebuzz follows you.
            fbz_user = User.objects.get(username__iexact='framebuzz')
            follow(fbz_user, instance)
            follow(instance, fbz_user)
        except User.DoesNotExist:
            # No framebuzz user, probably on a dev machine.
            pass

        for perm in comment_flag_permissions:
            profile.user.user_permissions.add(perm.id)
        return
Beispiel #36
0
def create_list(account: Account, user_input: Dict) -> Dict[str, Any]:
    expected_keys = [
        'id', 'name', 'enable_scans', 'scan_type', 'automated_scan_frequency',
        'scheduled_next_scan'
    ]
    if sorted(user_input.keys()) != sorted(expected_keys):
        return operation_response(error=True, message="Missing settings.")

    frequency = validate_list_automated_scan_frequency(
        user_input['automated_scan_frequency'])
    data = {
        'account': account,
        'name': validate_list_name(user_input['name']),
        'enable_scans': bool(user_input['enable_scans']),
        'scan_type': validate_list_scan_type(user_input['scan_type']),
        'automated_scan_frequency': frequency,
        'scheduled_next_scan': UrlList.determine_next_scan_moment(frequency),
    }

    urllist = UrlList(**data)
    urllist.save()

    # make sure the account is serializable.
    data['account'] = account.id

    # adding the ID makes it possible to add new urls to a new list.
    data['id'] = urllist.pk

    # empty list, no warnings.
    data['list_warnings'] = []

    # give a hint if it can be scanned:
    data['scan_now_available'] = urllist.is_scan_now_available()

    # Sprinkling an activity stream action.
    action.send(account, verb='created list', target=urllist, public=False)

    return operation_response(success=True, message="List created.", data=data)
Beispiel #37
0
def taskGroupCreate(request: HttpRequest, projectid):
    if not request.user.is_authenticated:
        return redirect('projectMgr:homepage')

    '''

    :param request:
    :return:
    '''
    print(request.method)
    print(request.POST)
    thisProject = models.Project.objects.get(id=projectid)

    if request.method == "POST":
        form = forms.createTaskgroup(request.POST)
        if form.is_valid():

            name = form.cleaned_data['name']
            description = form.cleaned_data['description']
            newTaskGroup = models.TaskGroup.objects.create(name=name, description=description, creator=request.user,created=datetime.now)
            newTaskGroup.people.add(request.user)
            newTaskGroup.save()
            thisProject = models.Project.objects.get(id=projectid)
            thisProject.taskgroup_set.add(newTaskGroup)
            thisProject.save()
            # create taskgroup activitiy
            action.send(request.user, verb="added taskgroup", action_object=newTaskGroup,
                        target=thisProject)
            # print('projectid',projectid,'taskgroupid',newTask.id)
            if "Choose team" in request.POST:
                return redirect('projectMgr:chooseTaskGroupMates', projectid=projectid, taskGroupId=newTaskGroup.id)
            else:
                return redirect('projectMgr:taskGroupDetail', projectid=projectid, taskGroupId=newTaskGroup.id)

    else:
        form = forms.createTaskgroup()

    return render(request, "projectMgr/createTaskGroup.html", {'form': form, 'project': thisProject, "thisUser": request.user})
Beispiel #38
0
def send_comment_notification(sender, instance, created, **kwargs):
    if created:
        action.send(instance.author,
                    verb='commented',
                    action_object=instance,
                    target=instance.video)
        if instance.author != instance.video.channel:
            Notification.objects.create(
                notification_type=Notification.NotificationType.COMMENT,
                actor=instance.author,
                action_object=instance,
                target_object=instance.video,
                recipient=instance.video.channel.user)
        tags = re.findall('@\(\w+\)\[([aA-zZ0-9-_]+)\]', instance.text)
        if tags:
            for channel in Channel.objects.filter(channel_id__in=tags):
                if instance.author != channel:
                    Notification.objects.create(
                        notification_type=Notification.NotificationType.TAG,
                        actor=instance.author,
                        action_object=instance,
                        target_object=instance.video,
                        recipient=channel.user)
Beispiel #39
0
    def get(self, request, *args, **kwargs):
        jardin = get_object_or_404(Jardin, pk=self.kwargs.get('jardin_id'))
        cultivateur = get_object_or_404(Cultivateur,
                                        pk=self.kwargs.get('cultivateur_id'))

        if cultivateur.jardin != jardin:
            return HttpResponseForbidden()

        if cultivateur.adherant.user != request.user:
            return HttpResponseForbidden()

        if cultivateur.pending or not cultivateur.accepte:
            return HttpResponseForbidden()

        cultivateur.accepte = False
        cultivateur.save()

        action.send(request.user, verb='quit', action_object=cultivateur)
        unfollow(cultivateur.adherant.user, jardin)

        CultivateurQuitMessageView(cultivateur, request).send()

        return redirect('s5appadherant:jardin_detail', jardin_id=jardin.id)
Beispiel #40
0
    def do_like(self, user_from, timestamp=None):
        self.can_vote(user_from)
        self.clear_previous_votes(user_from)
        data = {
            'verb': settings.FORUM_ACTION_UP_VOTE,
            'action_object': self,
        }
        if timestamp:
            data['timestamp'] = timestamp
        action.send(user_from, **data)

        if self.is_post:
            new_action_post.send(
                sender=self.__class__,
                instance=self,
                action=settings.FORUM_ACTION_UP_VOTE,
            )
        else:
            new_action_answer.send(
                sender=self.__class__,
                instance=self,
                action=settings.FORUM_ACTION_UP_VOTE,
            )
def get_report(account: Account, report_id: int):
    report = UrlListReport.objects.all().filter(
        urllist__account=account,
        urllist__is_deleted=False,
        pk=report_id
    ).values('id', 'urllist_id', 'calculation', 'average_internet_nl_score', 'total_urls', 'at_when', 'report_type',
             'urllist__name', 'is_publicly_shared', 'public_report_code', 'public_share_code'
             ).first()

    # todo: add report metadata...

    if not report:
        return []

    # Sprinkling an activity stream action.
    log_report = UrlListReport.objects.all().filter(
        urllist__account=account,
        urllist__is_deleted=False,
        pk=report_id
    ).only('id').first()
    action.send(account, verb='viewed report', target=log_report, public=False)

    return f"{dump_report_to_text_resembling_json(report)}"
Beispiel #42
0
    def handle(self, sender, signal, **kwargs):
        # only add things to the activity stream if there's a user
        if kwargs.get("user", None) is None:
            return

        target = self.getTargetObj(**kwargs)

        # invalidate cache for target followers
        users = followers(target)
        for user in users:
            update_activity_stream_for_user.delay(user.username)
        update_activity_stream_for_user.delay(kwargs['user'].username,
                                              actor=True)
        if signal == signals.create:
            action.send(kwargs['user'],
                        verb=self.createVerb,
                        action_object=kwargs['instance'],
                        target=target)
        if signal == signals.modify:
            action.send(kwargs['user'],
                        verb=self.modifyVerb,
                        action_object=kwargs['instance'],
                        target=target)
Beispiel #43
0
def on_failure(self, exc, task_id, args, kwargs, einfo):
    if isinstance(exc, SkipException):
        return None

    doc_id = args[0]
    print("Document {} failed.".format(doc_id))

    document = Document.objects.get(id=doc_id)
    document.state = "ERROR"
    document.save()
    action.send(document.user,
                verb="upload failed",
                action_object=document,
                target=document.course,
                public=False)

    # Warn the admins
    DocumentError.objects.create(
        document=document,
        task_id=task_id,
        exception=exc,
        traceback=einfo.traceback,
    )
def record_bill_proposal(**kwargs):
    if kwargs['action'] != "post_add":
        return
    private_proposal_ct = ContentType.objects.get(app_label="laws",
                                                  model="privateproposal")
    member_ct = ContentType.objects.get(app_label="mks", model="member")
    proposal = kwargs['instance']
    if str(kwargs['sender']).find('proposers') >= 0:
        verb = 'proposed'
    else:
        verb = 'joined'
    for mk_id in kwargs['pk_set']:
        if Action.objects.filter(
                actor_object_id=mk_id,
                actor_content_type=member_ct,
                verb=verb,
                target_object_id=proposal.id,
                target_content_type=private_proposal_ct).count() == 0:
            mk = Member.objects.get(pk=mk_id)
            action.send(mk,
                        verb=verb,
                        target=proposal,
                        timestamp=proposal.date)
Beispiel #45
0
def update_node_property(user, action_object, property_key, value_before, value_after):
    """
    Creates an Action with the extra information needed to present the user with a history.
    :param user: Django user instance
    :param action_object: NodeHandle instance
    :param property_key: String
    :param value_before: JSON supported value
    :param value_after: JSON supported value
    :return: None
    """
    action_object.modifier = user
    action_object.save()
    action.send(
        user,
        verb='update',
        action_object=action_object,
        noclook={
            'action_type': 'node_property',
            'property': property_key,
            'value_before': value_before,
            'value_after': value_after
        }
    )
Beispiel #46
0
def delete_relationship(user, relationship):
    """
    :param user: Django user instance
    :param relationship: norduniclient relationship model
    :return: None
    """
    start_nh = NodeHandle.objects.get(pk=relationship.start['handle_id'])
    start_nh.modifier = user
    start_nh.save()
    end_nh = NodeHandle.objects.get(pk=relationship.end['handle_id'])
    end_nh.modifier = user
    end_nh.save()
    action.send(
        user,
        verb='delete',
        action_object=start_nh,
        target=end_nh,
        noclook={
            'action_type': 'relationship',
            'relationship_type': relationship.type,
            'object_name': u'{}'.format(relationship.data)
        }
    )
Beispiel #47
0
    def _handle_add_mk(self, cm, request):
        mk_id = request.POST.get('mk_id')
        mk_name = request.POST.get('mk_name')
        if not mk_id and mk_name:
            mk_names = Member.objects.values_list('name', flat=True)
            possible_matches = difflib.get_close_matches(mk_name, mk_names)
            if possible_matches:
                mk_name = possible_matches[0]
                mk = Member.objects.get(name=mk_name)
            else:
                raise Http404()

        elif mk_id:
            mk = Member.objects.get(id=mk_id)
        else:
            raise Http404()
        cm.mks_attended.add(mk)
        cm.save()  # just to signal, so the attended Action gets created.
        action.send(request.user,
                    verb='added-mk-to-cm',
                    description=cm,
                    target=mk,
                    timestamp=datetime.datetime.now())
Beispiel #48
0
    def save(self, *args, **kwargs):
        """Extend save() with reel thumbnail fetching.

        If reel is set, fetch thumbnail_url via micawber and set it as reel_thumbnail.
        """
        super().save(*args, **kwargs)

        if self.reel == '':
            log.debug('Skipping thumbnail fetch for reel of profile %i' %
                      self.user_id)
            return
        if self.data_changed(['reel']):
            log.debug('Updating reel thumbnail for user %i' % self.user_id)
            dillo.tasks.profile.update_profile_reel_thumbnail(self.user_id)
            # Create activity for reel update
            action.send(self.user,
                        verb='updated their reel',
                        action_object=self)

        if self.data_changed(['name']):
            log.debug('Updating newsletter information for user')
            dillo.tasks.profile.update_mailing_list_subscription(
                self.user.email)
Beispiel #49
0
def video_signup(request, slug):
    if not request.method == 'POST':
        raise Exception('This view is meant to be called via a POST request.')

    video, created = get_or_create_video(slug)
    login_success = False
    outbound_message = dict()
    outbound_message[DATA_KEY] = {}
    form = SignupForm(data=json.loads(request.raw_post_data))

    if form.is_valid():
        user = form.save(request)
        perform_login(request, user)
        login_success = True

        action.send(user, verb='registered account', action_object=video)
        action.send(user, verb='viewed video', action_object=video)

        userSerializer = UserSerializer(user)
        userSerialized = JSONRenderer().render(userSerializer.data)
        outbound_message[DATA_KEY]['user'] = json.loads(userSerialized)
        outbound_message[DATA_KEY]['share_url'] = reverse('profiles-share',
                                                          args=[
                                                              user.username,
                                                              slug,
                                                          ])
    else:
        outbound_message[DATA_KEY]['errors'] = \
            json.loads(errors_to_json(form.errors))

    outbound_message[EVENT_TYPE_KEY] = 'FB_SIGNUP'
    outbound_message[CHANNEL_KEY] = \
        '/framebuzz/session/%s' % request.session.session_key
    outbound_message[DATA_KEY]['login_success'] = login_success

    return HttpResponse(json.dumps(outbound_message),
                        content_type="application/json")
Beispiel #50
0
    def post(self, request, **kwargs):
        cm = get_object_or_404(CommitteeMeeting, pk=kwargs['pk'])
        bill = None
        request = self.request
        user_input_type = request.POST.get('user_input_type')
        if user_input_type == 'bill':
            bill_id = request.POST.get('bill_id')
            if bill_id.isdigit():
                bill = get_object_or_404(Bill, pk=bill_id)
            else: # not a number, maybe its p/1234
                m = re.findall('\d+',bill_id)
                if len(m)!=1:
                    raise ValueError("didn't find exactly 1 number in bill_id=%s" % bill_id)
                pp = PrivateProposal.objects.get(proposal_id=m[0])
                bill = pp.bill

            if bill.stage in ['1','2','-2','3']: # this bill is in early stage, so cm must be one of the first meetings
                bill.first_committee_meetings.add(cm)
            else: # this bill is in later stages
                v = bill.first_vote # look for first vote
                if v and v.time.date() < cm.date:          # and check if the cm is after it,
                    bill.second_committee_meetings.add(cm) # if so, this is a second committee meeting
                else: # otherwise, assume its first cms.
                    bill.first_committee_meetings.add(cm)
            bill.update_stage()
            action.send(request.user, verb='added-bill-to-cm',
                description=cm,
                target=bill,
                timestamp=datetime.datetime.now())

        if user_input_type == 'mk':
            mk_names = Member.objects.values_list('name', flat=True)
            mk_name = difflib.get_close_matches(request.POST.get('mk_name'),
                                                mk_names)[0]
            mk = Member.objects.get(name=mk_name)
            cm.mks_attended.add(mk)
            cm.save()  # just to signal, so the attended Action gets created.
            action.send(request.user,
                        verb='added-mk-to-cm',
                        description=cm,
                        target=mk,
                        timestamp=datetime.datetime.now())

        if user_input_type == 'remove-mk':
            mk_names = Member.objects.values_list('name', flat=True)
            mk_name = difflib.get_close_matches(request.POST.get('mk_name'),
                                                mk_names)[0]
            mk = Member.objects.get(name=mk_name)
            cm.mks_attended.remove(mk)
            cm.save()  # just to signal, so the attended Action gets created.
            action.send(request.user,
                        verb='removed-mk-to-cm',
                        description=cm,
                        target=mk,
                        timestamp=datetime.datetime.now())

        return HttpResponseRedirect(".")
Beispiel #51
0
def BadgeWearAddView(request, pk=0):
    if pk == 0:
        return HttpResponseRedirect(reverse('badges_home_view'))

    form = BadgeWearForm()
    badge = get_object_or_404(Badge, pk=pk)
    badgeWear = request.user.badgewear_set.filter(badge=badge)

    if not badgeWear or badgeWear[0].level != "MAI":
        return HttpResponseForbidden("Vous n'avez pas \
            les droits pour effectuer cette action")

    if request.method == "POST":
        form = BadgeWearForm(request.POST)

        if form.is_valid():

            badgeWear = BadgeWear(user=form.cleaned_data['user'])
            badgeWear.badge = badge
            badgeWear.level = form.cleaned_data['level']
            badgeWear.action_counter = 0
            badgeWear.timestamp = timezone.now()
            badgeWear.attributor = request.user
            badgeWear.save()

            if not badge.hidden:
                djaction.send(form.cleaned_data['user'],
                              verb='a recu le badge',
                              action_object=badge)

            return HttpResponseRedirect(
                reverse('badge_view', kwargs={"pk": pk}))
    else:
        return render(request, 'add_badgewear.html', {
            'form': form,
            'badge': badge
        })
Beispiel #52
0
def new_group_post(request):
    image_url = ''
    viewer = request.user
    owner_user = request.user
    owner_user_role = UserProfile.objects.get(user_id=owner_user.id)
    if request.method == 'POST':
        eform = freeCrop(request.POST)  # A form bound to the POST data
        if eform.is_valid():  # All validation rules pass
            new_event = eform.save()
            #return HttpResponseRedirect('/user/profile/'+request.user.username)
            #return HttpResponseRedirect('/file-upload/cicu-freecrop/?id='+str(new_event.id))
            a = new_event.id
            if uploadedImage.objects.get(id=a).image:
                image_url = "###uploaded_image###" + uploadedImage.objects.get(
                    id=a).image.url + "##!uploaded_image!##"
        form = Group_Post_Form(request.POST)
        if form.is_valid():
            ######## form values ###########
            content = form.cleaned_data['content'] + image_url
            actor_name = form.cleaned_data['actor_name']
            group_id = form.cleaned_data['group_id']
            #####################
            owner_user_role = UserProfile.objects.get(user_id=owner_user.id)
            org = Organization.objects.get(id=group_id)
            content = rendered_content(content, request)
            action.send(viewer,
                        verb='posted',
                        action_object=org,
                        target=org,
                        post_content=content)  # action creation
        else:
            print "ERROR IN VALIDATION"
            print form.errors
    else:
        form = Group_Post_Form()

    return HttpResponseRedirect('/groups/' + group_id)
Beispiel #53
0
def promote_user(request, action="", username="", pk=""):
    user = get_object_or_404(User, username=username)
    badge = get_object_or_404(Badge, pk=int(pk))
    badge_wear = get_object_or_404(BadgeWear, badge=badge, user=user)

    if get_object_or_404(BadgeWear, badge=badge,
                         user=request.user).level != "MAI":
        return HttpResponseForbidden("Vous n'avez pas les droits requis pour \
            effectuer cette action")

    if action == "up":
        if badge_wear.level == "DIS":
            badge_wear.level = "MAI"
        elif badge_wear.level == "INI":
            badge_wear.level = "DIS"
        elif badge_wear.level == "RAC":
            badge_wear.level = "INI"
        if not badge.hidden:
            djaction.send(user,
                          verb='a été promu "{}" pour le badge'.format(
                              badge_wear.get_level_display()),
                          action_object=badge)

    elif action == "down":
        if badge_wear.level == "INI":
            badge_wear.level = "RAC"
        elif badge_wear.level == "DIS":
            badge_wear.level = "INI"
        elif badge_wear.level == "MAI":
            badge_wear.level = "DIS"
    else:
        return HttpResponseForbidden(
            "L'action que vous tentez d'effectuer n'existe pas")
    badge_wear.timestamp = timezone.now()
    badge_wear.save()

    return HttpResponseRedirect(reverse("badge_view", args=[pk]))
Beispiel #54
0
 def save(self, *args, **kwargs):
     #add issue status to activity feed
     if self.status == Issue.IN_REVIEW_STATUS:
         action.send(self.user, verb="is in review now", target=self.number)
     elif self.status == Issue.OPEN_STATUS:
         action.send(self.user, verb="is open now", target=self.number)
     else:
         action.send(self.user, verb="is closed", target=self.number)
     super(Issue, self).save(*args, **kwargs)
Beispiel #55
0
def project_step_create_edit(request, project_slug, project_step_number=None):
    user = request.user
    project = get_object_or_404(Project, slug=project_slug)
    if not project.is_editable(request):
        return HttpResponseForbidden('You are not the owner of this project.')
    if 'add' in request.path and project.steps.count() >= 20:
        messages.add_message(request, messages.WARNING,
                             'This project already contains 20 steps.')
        return redirect('project-detail', project.slug)
    if project_step_number is not None:
        project_step = get_object_or_404(ProjectStep,
                                         project=project,
                                         _order=project_step_number)
    else:
        project_step = ProjectStep(project=project)
    project_step_form = ProjectStepForm(request.POST or None,
                                        instance=project_step)
    if project_step_form.is_valid():
        project_step_form.save()
        if project.is_published():
            action.send(user,
                        verb='updated',
                        action_object=project_step,
                        target=project)
        # User clicked "save and add another"
        if 'save-add' in request.POST:
            redirect_args = ('project-step-create-edit', project.slug)
        # User clicked "save" (catch anything else)
        else:
            redirect_args = (project, )
        return redirect(*redirect_args)
    return render(
        request, 'project/project_step_create_edit.html', {
            'project': project,
            'project_step': project_step,
            'project_step_form': project_step_form,
        })
Beispiel #56
0
def on_created_like(sender, instance: dillo.models.mixins.Likes, created, **kwargs):
    """Actions to perform once a Like is created."""

    if (
        isinstance(instance.content_object, dillo.models.comments.Comment)
        and instance.content_object.parent_comment
    ):
        target = instance.content_object.parent_comment
    else:
        target = None

    log.debug('Generating like activity')
    # TODO(fsiddi) Prevent duplicate activity.
    # If the user likes a post or comment after having unliked it, do not generate activity.
    action.send(instance.user, verb='liked', action_object=instance.content_object, target=target)

    # Increase likes_count for profile of content owner their content is liked.
    if not created:
        return
    target_user = instance.content_object.user
    dillo.models.profiles.Profile.objects.filter(user=target_user).update(
        likes_count=F('likes_count') + 1
    )
    log.debug('Increased like count for user %s' % target_user)
Beispiel #57
0
def website_post_add_or_edit(sender, instance, **kwargs):
    """
    receive signals when user adding/editing Post Website
    """
    user = instance.author

    if kwargs.get('created', False):
        add_actor = Actor.objects.get(user=user)
        add_activity = Verb.objects.get(name='website_post_adding')
        add_object = Object.objects.create(obj_id=instance.pk,
                                           obj_text=instance.title)
        action.send(add_actor,
                    verb=add_activity,
                    description=add_activity.description,
                    action_object=add_object)
    else:
        edit_actor = Actor.objects.get(user=user)
        edit_activity = Verb.objects.get(name='website_post_editing')
        edit_object = Object.objects.create(obj_id=instance.pk,
                                            obj_text=instance.title)
        action.send(edit_actor,
                    verb=edit_activity,
                    description=edit_activity.description,
                    action_object=edit_object)
Beispiel #58
0
def event_assessment_add_or_edit(sender, instance, **kwargs):
    """
    receive signals when user adding/editing Event Assessment Disaster Rehabilitation
    """
    user = get_current_user()

    if kwargs.get("created", False):
        add_actor = Actor.objects.get(user=user)
        add_activity = Verb.objects.get(name='event_assessment_adding')
        add_object = Object.objects.create(obj_id=instance.pk,
                                           obj_text=instance.name)
        action.send(add_actor,
                    verb=add_activity,
                    description=add_activity.description,
                    action_object=add_object)
    else:
        edit_actor = Actor.objects.get(user=user)
        edit_activity = Verb.objects.get(name='event_assessment_editing')
        edit_object = Object.objects.create(obj_id=instance.pk,
                                            obj_text=instance.name)
        action.send(edit_actor,
                    verb=edit_activity,
                    description=edit_activity.description,
                    action_object=edit_object)
Beispiel #59
0
def website_video_add_or_edit(sender, instance, **kwargs):
    """
    receive signals when user adding/editing Video Website
    """
    user = get_current_user()

    if kwargs.get("created", False):
        add_actor = Actor.objects.get(user=user)
        add_activity = Verb.objects.get(name='website_video_adding')
        add_object = Object.objects.create(obj_id=instance.pk,
                                           obj_text=instance.title)
        action.send(add_actor,
                    verb=add_activity,
                    description=add_activity.description,
                    action_object=add_object)
    else:
        edit_actor = Actor.objects.get(user=user)
        edit_activity = Verb.objects.get(name='website_video_editing')
        edit_object = Object.objects.create(obj_id=instance.pk,
                                            obj_text=instance.title)
        action.send(edit_actor,
                    verb=edit_activity,
                    description=edit_activity.description,
                    action_object=edit_object)
Beispiel #60
0
def waterlevel_report_add_or_edit(sender, instance, **kwargs):
    """
    receive signals when user adding/editing WaterLevelReport
    """
    user = get_current_user()

    if kwargs.get('created', False):
        add_actor = Actor.objects.get(user=user)
        add_activity = Verb.objects.get(name='waterlevel_report_adding')
        add_object = Object.objects.create(obj_id=instance.pk,
                                           obj_text=instance.watergate)
        action.send(add_actor,
                    verb=add_activity,
                    description=add_activity.description,
                    action_object=add_object)
    else:
        edit_actor = Actor.objects.get(user=user)
        edit_activity = Verb.objects.get(name='sensor_report_adding')
        edit_object = Object.objects.create(obj_id=instance.pk,
                                            obj_text=instance.watergate)
        action.send(edit_actor,
                    verb=edit_activity,
                    description=edit_activity.description,
                    action_object=edit_object)