def add_friend(request): if not request.user.is_authenticated(): return redirect(gethome()) if request.method != 'POST': return redirect(gethome()) else: print "HELLO I AM AT AN AJAX CALL AT FRIENDS.VIEW.add_friend-----------------------------------------------------" print request.POST if "user2" in request.POST: user2_id = request.POST["user2"] Profile2_object = Profile.objects.filter(id=user2_id) user2 = Profile2_object[0].user user1 = request.user #user who clicked add friend ==> userFrom message = Profile2_object[0].first_name + " " + Profile2_object[0].last_name + " wants to be friends with you" if checkFriendExisted(user1,user2) == True: return redirect(gethome()) #-------------BETA-------------------------------------# user2_uuid = Profile2_object[0].id user1_uuid = Profile.objects.filter(user=user1)[0].id #-------------BETA-------------------------------------# friend_object = Friends(user1=user1,user2=user2,status = "P",user1_uuid=user1_uuid,user2_uuid=user2_uuid) friend_object.save() if(checkNotificationExisted(user1,user2,"F") == False): notification_object = Notification( user1=user1, user2=user2, message=message, read=False, notification_type="FR", target_id=friend_object.friends_id, user1_uuid=user1_uuid, user2_uuid=user2_uuid) notification_object.save() print "-------------DONE-----------------" return redirect(gethome())
def add_friend(request): if request.method == "POST" and request.is_ajax(): context = {} user1 = request.user user1_profile = Profile.objects.get(user=user1) user1_uuid = user1_profile.id user2_uuid = request.POST['user2_uuid'] user2_profile = Profile.objects.get(id=user2_uuid) user2 = user2_profile.user friend_object = Friends(user1=user1,user2=user2,status = "P",user1_uuid=user1_uuid,user2_uuid=user2_uuid) message = user1_profile.first_name + " " + user1_profile.last_name + "shows interest with you" friend_object.save() notification_object = Notification( user1=user1, user2=user2, message=message, read=False, notification_type="I", target_id=friend_object.roomate_id, user1_uuid=user1_uuid, user2_uuid=user2_uuid, ) notification_object.save() return render(request,"error.html",{}) return render(request,"error.html",{})
def test_notification_send(self): notifications = Notification.objects.all() self.assertEqual(1, len(notifications)) self.assertEqual(self.student.userprofile, notifications[0].sender) self.assertEqual(self.teacher.userprofile, notifications[0].recipient) self.assertEqual(self.course_instance, notifications[0].course_instance) self.assertEqual("testSubject", notifications[0].subject) self.assertEqual("testNotification", notifications[0].notification) self.assertFalse(notifications[0].seen) Notification.send(self.teacher.userprofile, self.student.userprofile, self.course_instance, "subject", "notification") notifications = Notification.objects.all() self.assertEqual(2, len(notifications)) self.assertEqual(self.teacher.userprofile, notifications[0].sender) self.assertEqual(self.student.userprofile, notifications[0].recipient) self.assertEqual(self.course_instance, notifications[0].course_instance) self.assertEqual("subject", notifications[0].subject) self.assertEqual("notification", notifications[0].notification) self.assertFalse(notifications[0].seen) self.assertEqual(self.student.userprofile, notifications[1].sender) self.assertEqual(self.teacher.userprofile, notifications[1].recipient) self.assertEqual(self.course_instance, notifications[1].course_instance) self.assertEqual("testSubject", notifications[1].subject) self.assertEqual("testNotification", notifications[1].notification) self.assertFalse(notifications[1].seen)
def add_tweet(request): html = 'add_tweet.html' notifcation_count = Notification.objects.filter(user=request.user).count() if request.method == "POST": form = AddTweetForm(request.POST) if form.is_valid(): new_tweet = form.save(commit=False) new_tweet.profile = request.user new_tweet.save() # check to see if there is any mentions and add notification if there is reg = re.compile(r'(.*)(@\S*)') m = reg.match(new_tweet.content) if m: if Profile.objects.filter(handle=m[2][1:]): new_notification = Notification( user=Profile.objects.get(handle=m[2][1:]), tweet=new_tweet) new_notification.save() return HttpResponseRedirect(reverse('homepage')) form = AddTweetForm() return render(request, html, { 'form': form, 'notifcation_count': notifcation_count })
def generateDangerNotification(request): user = request.user bankingP = BankingPerson.objects.get(user=user) if bankingP.receiveDanger: n = Notification(title="Danger danger, we're gonna die", text="LAY, indeed, thought I, and such a lay! the seven hundred and seventy-seventh! Well, old Bildad, you are determined that I, for one, shall not LAY up many LAYS here below, where moth and rust do corrupt. It was an exceedingly LONG LAY that, indeed; and though from the magnitude of the figure it might at first deceive a landsman, yet the slightest consideration will show that though seven hundred and seventy-seven is a pretty large number, yet, when you come to make a TEENTH of it, you will then see, I say, that the seven hundred and seventy-seventh part of a farthing is a good deal less than seven hundred and seventy-seven gold doubloons; and so I thought at the time.", level = 3, to=user) n.save() return HttpResponseRedirect("/")
def form_valid(self, form): assistant_feedback = form.cleaned_data["assistant_feedback"] feedback = form.cleaned_data["feedback"] note = "" if self.submission.assistant_feedback != assistant_feedback: note = assistant_feedback elif self.submission.feedback != feedback: note = feedback self.submission.set_points(form.cleaned_data["points"], self.exercise.max_points, no_penalties=True) self.submission.grader = self.profile self.submission.assistant_feedback = assistant_feedback self.submission.feedback = feedback self.submission.set_ready() self.submission.save() sub = _('Feedback to {name}').format(name=self.exercise) msg = _('<p>You have new personal feedback to exercise ' '<a href="{url}">{name}</a>.</p>{message}').format( url=self.submission.get_absolute_url(), name=self.exercise, message=note, ) for student in self.submission.submitters.all(): Notification.send(self.profile, student, self.instance, sub, msg) messages.success(self.request, _("The review was saved successfully " "and the submitters were notified.")) return super().form_valid(form)
def reply_topic(request, pk, topic_pk): topic = get_object_or_404(Topic, board__pk=pk, pk=topic_pk) if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): post = form.save(commit=False) post.topic = topic post.created_by = request.user post.save() topic.last_updated = timezone.now() topic.save() topic_url = reverse('topic_posts', kwargs={ 'pk': pk, 'topic_pk': topic_pk}) if post.created_by.username != topic.starter.username: topic_notif = post.created_by.username + ' replied to ' + topic.subject notif = Notification( user=topic.starter, message=topic_notif, level=2, link=topic_url, fa_type='fa-edit') notif.save() messages.add_message(request, messages.SUCCESS, 'Reply to the topic successfull.') return redirect('topic_posts', pk=pk, topic_pk=topic_pk) else: form = PostForm() return render(request, 'reply_topic.html', {'topic': topic, 'form': form})
def show_interest(request): if request.method == "POST" and request.is_ajax(): print "AJAX------------------------------------SHOW INTEREST" context = {} #----GET VARIABLES---# user1 = request.user user1_profile = Profile.objects.get(user=user1) user1_uuid = user1_profile.id user2_uuid = request.POST['user2_uuid'] user2_profile = Profile.objects.get(id=user2_uuid) user2 = user2_profile.user #----INTERESTS ARE DIRECTED GRAPHS----# friends_object = Friends(user1=user1,user2=user2,status = "I",user1_uuid=user1_uuid,user2_uuid=user2_uuid) friends_object.save() message = user1_profile.first_name + " " + user1_profile.last_name + " shown interest on you" notification_object = Notification( user1=user1, user2=user2, message=message, read=False, notification_type="SI", target_id=friends_object.friends_id, user1_uuid=user1_uuid, user2_uuid=user2_uuid ) notification_object.save() print user2_uuid; notification_delete = request.POST['notification_delete'] if notification_delete == "ok": notification_id = request.POST['notification_id'] notification_object_delete = Notification.objects.get(notification_id=notification_id) notification_object_delete.delete() return render(request,'error.html',context) return render(request,'error.html',{})
def generateWarningNotification(request): user = request.user bankingP = BankingPerson.objects.get(user=user) if bankingP.receiveWarning: n = Notification(title="BE WARNED, mortal", text="But one thing, nevertheless, that made me a little distrustful about receiving a generous share of the profits was this: Ashore, I had heard something of both Captain Peleg and his unaccountable old crony Bildad; how that they being the principal proprietors of the Pequod, therefore the other and more inconsiderable and scattered owners, left nearly the whole management of the ship's affairs to these two. And I did not know but what the stingy old Bildad might have a mighty deal to say about shipping hands, especially as I now found him on board the Pequod, quite at home there in the cabin, and reading his Bible as if at his own fireside. Now while Peleg was vainly trying to mend a pen with his jack-knife, old Bildad, to my no small surprise, considering that he was such an interested party in these proceedings; Bildad never heeded us, but went on mumbling to himself out of his book, 'LAY not up for yourselves treasures upon earth, where moth.", level = 2, to=user) n.save() return HttpResponseRedirect("/")
def save(self, *args, **kwargs): markdown = Markdown() self.content_html = markdown.render(self.content) super().save(*args, **kwargs) from notification.models import Notification Notification.create_notifications_from_reply( reply=self, mentions=markdown.get_mentions())
def event_register(request, slug): if not request.user.is_authenticated: return redirect('{}?next={}'.format(settings.LOGIN_URL, request.path)) attendee_name = request.user.first_name attendee_surname = request.user.last_name attendee_email = request.user.email form = EventRegisterForm(request.POST or None, request.FILES or None, initial={ 'first_name': attendee_name, 'last_name': attendee_surname, 'email': attendee_email, }) if form.is_valid(): # name = form.cleaned_data.get('first_name') # surname = form.cleaned_data.get('last_name') # email = form.cleaned_data.get('email') event = get_object_or_404(Event, slug=slug) request.user.registered_events.add(event) Notification.send(actor=event, receiver=event.organizer, message='Your event has a new attendee.') messages.success(request, "You have successfuly registered the event.") return HttpResponseRedirect(event.get_absolute_url()) return render(request, "crispy/form.html", { "form": form, "title": "Register Event" })
def envoyer_commentaire_notification(self, comment_pk, username): eleve = UserProfile.objects.get(user__username=username) message = eleve.first_name + " " + eleve.last_name + " a commente un message de " + self.association.nom commentaire = Comment.objects.get(pk=comment_pk) notification = Notification(content_object=commentaire, description=message) notification.save() notification.envoyer_multiple(self.association.suivi_par.all())
def add_roomate(request): print "AJAX---------------------------------------ROOMATE REQUEST" if request.method == "POST" and request.is_ajax(): print "AJAX----ADD_ROOMATE" context = {} user1 = request.user user1_profile = Profile.objects.get(user=user1) user1_uuid = user1_profile.id user2_uuid = request.POST['user2_uuid'] user2_profile = Profile.objects.get(id=user2_uuid) user2 = user2_profile.user roomate_object = Roomate(user1=user1,user2=user2,status = "P",user1_uuid=user1_uuid,user2_uuid=user2_uuid) roomate_object.save() message = user1_profile.first_name + " " + user1_profile.last_name + " wants to be roomates with you" notification_object = Notification( user1=user1, user2=user2, message=message, read=False, notification_type="RR", target_id=roomate_object.roomate_id, user1_uuid=user1_uuid, user2_uuid=user2_uuid ) notification_object.save() print user2_uuid; return render(request,'error.html',context) return render(request,'error.html',{})
def test_notification_updated_on_request_aborted(self): project = self.create(Project, role=self.admin_role) normal_user = self.create(User) join_request = ProjectJoinRequest.objects.create( project=project, requested_by=normal_user, role=self.normal_role, data={'reason': 'bla'}) # Get notification for self.user notifications = Notification.get_for(self.user) assert notifications.count() == 1 assert notifications[0].notification_type ==\ Notification.Type.PROJECT_JOIN_REQUEST assert notifications[0].data['status'] == 'pending' # Now abort join request by deleting it join_request.delete() # Get notifications again notifications = Notification.get_for(self.user) assert notifications.count() == 2 new_notif = notifications.order_by('-timestamp')[0] assert new_notif.data['status'] == 'aborted' assert new_notif.notification_type ==\ Notification.Type.PROJECT_JOIN_REQUEST_ABORT # Get notifications for requesting user # there should be none notifications = Notification.get_for(normal_user) assert notifications.count() == 0
def register_pill_by_name(request): '''This method is for the autosuggestion used in manual lookup. This method is for registering pills using the name, not the id''' if request.method == 'POST': if request.user.is_authenticated: try: req_data = json.loads(request.body.decode()) except (KeyError, ValueError): return HttpResponseBadRequest() pill_name = req_data['pill_name'] pill_company = req_data['pill_company'] new_pill = Pill.objects.get(product_name=pill_name, company_name=pill_company, custom=False) existing_pill_names = request.user.pills.all().values_list( 'product_name', flat=True) if pill_name in existing_pill_names: return HttpResponse(status=status.HTTP_400_BAD_REQUEST) request.user.pills.add(new_pill) Notification.create(request.user, new_pill) new_pill_dict = get_pill_dict(new_pill) return JsonResponse(new_pill_dict, status=status.HTTP_201_CREATED) else: return HttpResponse(status=401) else: return HttpResponseNotAllowed(['POST'])
def change_status(self, value): not_send_notification_statuses = ( "wait", "payment_check", "inspector_check", ) if self.status is not value: self.status = value self.save() if self.status not in not_send_notification_statuses: notification = Notification(owner=self.owner, boat=self, status=self.status) notification.save() sms_message = get_message_text_by_status( status=self.status, boat_name=self.name, extra_data=notification.extra_data) if sms_message: send_sms(self.owner.phone_number, sms_message) if notification.status == "payment_rejected": notification.boat.change_status("payment")
def test_notification_created_on_project_join_request(self): project = self.create(Project, role=self.admin_role) # Create users normal_user = self.create(User) admin_user = self.create(User) # Add admin user to project project.add_member(admin_user, role=self.admin_role) ProjectJoinRequest.objects.create(project=project, requested_by=normal_user, role=self.normal_role, data={'reason': 'bla'}) # Get notifications for admin_users for user in [self.user, admin_user]: notifications = Notification.get_for(user) assert notifications.count() == 1,\ "A notification should have been created for admin" notification = notifications[0] assert notification.status == Notification.Status.UNSEEN assert notification.notification_type ==\ Notification.Type.PROJECT_JOIN_REQUEST assert notification.receiver == user assert notification.data['status'] == 'pending' assert notification.data['data']['reason'] is not None # Get notifications for requesting user # there should be none notifications = Notification.get_for(normal_user) assert notifications.count() == 0
def post(self, request, pill_id): """ add new pill item for user <int:pk> """ if request.user.is_authenticated: # check if pill_id already exists in user's pills existing_pills = request.user.pills.all().values_list('id', flat=True) if pill_id in existing_pills: return HttpResponse(status=status.HTTP_400_BAD_REQUEST) # get pill object from Pill model by id new_pill = Pill.objects.get(pk=pill_id) # add retrieved pill object to current user's pills field request.user.pills.add(new_pill) # add notification for the new pill Notification.create(request.user, new_pill) image_query = Image.objects.filter(user=request.user, pill=new_pill) if image_query.exists(): image_instance = image_query[0] new_pill_dict = get_pill_dict(new_pill, image_instance) else: new_pill_dict = get_pill_dict(new_pill) # new_pill_dict = get_pill_dict(new_pill) return JsonResponse(new_pill_dict, status=status.HTTP_201_CREATED) else: return HttpResponse(status=status.HTTP_401_UNAUTHORIZED)
def team_invite(request): # Get POST data payload = request.POST.get('value') # Try to decode the scrambled team pk try: data = decode_data(payload) except Exception: print("bad hash") return JsonResponse({'status': 'ko'}) user_id = int(data[0]) team_id = int(data[1]) # Try to get the team try: team = get_object_or_404(Team, pk=team_id) except Http404: print("team not found", team_id) return JsonResponse({'status': 'ko'}) # Double check that the request does not already exist if Notification.objects.filter( user_from=request.user, user_to_id=user_id, foreignPK=team_id, context=Notification.contexts.team.name, action=Notification.actions.team_invite.name, url=payload, read=False, ).exists(): print("did exist") return JsonResponse({'status': 'ko'}) # Double check that the request does not already exist elif Notification.objects.filter( user_from_id=user_id, foreignPK=team_id, context=Notification.contexts.team.name, action=Notification.actions.team_req_join, url=payload, read=False, ).exists(): print("did exist") return JsonResponse({'status': 'ko'}) # Generate payload payload = encode_data([request.user.pk, team_id]) # Generate a request notification notif_req = Notification( user_from=request.user, user_to_id=user_id, foreignPK=team_id, context=Notification.contexts.team.name, action=Notification.actions.team_invite.name, url=payload, ) notif_req.save() # Return a successful response return JsonResponse({'status': 'ok'})
def generateInfoNotification(request): user = request.user bankingP = BankingPerson.objects.get(user=user) if bankingP.receiveInfo: n = Notification(title="Information triggered", text="I thought him the queerest old Quaker I ever saw, especially as Peleg,his friend and old shipmate, seemed such a blusterer. But I said nothing, only looking round me sharply. Peleg now threw open a chest, and drawing forth the ship's articles, placed pen and ink before him, and seated himself at a little table. I began to think it was high time to settle with myself at what terms I would be willing to engage for the voyage. I was already aware that in the whaling business they paid no wages; but all hands, including the captain, received certain shares of the profits called lays, and that these lays were proportioned to the degree of importance pertaining to the respective duties of the ship's company. I was also aware that being a green hand at whaling, my own lay would not be very large; but considering that I was used to the sea, could steer a ship, splice a rope, and all that, I made no doubt that from all I had heard I should be offered at least the 275th lay--that is, the 275th part of the clear net proceeds of the voyage, whatever that might eventually amount to. And though the 275th lay was what they call a rather LONG LAY, yet it was better than nothing; and if we had a lucky voyage, might pretty nearly pay for the clothing I would wear out on it, not to speak of my three years' beef and board, for which I would not have to pay one stiver.", level = 0, to=user) n.save() return HttpResponseRedirect("/")
def handle(self, *args, **kwargs): now = timezone.now() meal_list = Meal.objects.filter( scheduled_for__lt=now, review__isnull=True, status='a', ) for meal in meal_list: print "Creating a KitchenReview object and sending email " \ "for meal with ID: %d" % meal.id token = get_random_string() kitchen_review = KitchenReview.objects.create( token=token, guest=meal.guest, kitchen=meal.kitchen, ) meal.review = kitchen_review meal.save() Notification.notify( 'invite_guest_review', { 'to_address': meal.guest.email, 'meal': meal, 'kitchen_review': kitchen_review, } )
def LikeView(request): post = get_object_or_404(Post, id=request.POST.get('id')) liked = False if post.likes.filter(id=request.user.id).exists(): post.likes.remove(request.user) liked = False notify = Notification.objects.filter(post=post, sender=request.user, notification_type=1) notify.delete() else: post.likes.add(request.user) liked = True notify = Notification(post=post, sender=request.user, user=post.author, notification_type=1) notify.save() context = { 'post': post, 'total_likes': post.total_likes(), 'liked': liked, } if request.is_ajax(): html = render_to_string('blog/like_section.html', context, request=request) return JsonResponse({'form': html})
def form_valid(self, form): assistant_feedback = form.cleaned_data["assistant_feedback"] feedback = form.cleaned_data["feedback"] note = "" if self.submission.assistant_feedback != assistant_feedback: note = assistant_feedback elif self.submission.feedback != feedback: note = feedback self.submission.set_points(form.cleaned_data["points"], self.exercise.max_points, no_penalties=True) self.submission.grader = self.profile self.submission.assistant_feedback = assistant_feedback self.submission.feedback = feedback self.submission.set_ready() self.submission.save() #sub = _('Feedback to {name}').format(name=self.exercise) #msg = _('<p>You have new personal feedback to exercise ' # '<a href="{url}">{name}</a>.</p>{message}').format( # url=self.submission.get_absolute_url(), # name=self.exercise, # message=note, #) Notification.send(self.profile, self.submission) messages.success( self.request, _("The review was saved successfully " "and the submitters were notified.")) return super().form_valid(form)
def post(self, request, *args, **kwargs): check_if_user(request) id = request.user.id user = TemplateUser.objects.get(id=id) following = request.data['following'] query = Follow.objects.filter(following=following, follower=user) if query: raise ValidationError( {"detail": 'You have already follow this person'}) user_following = TemplateUser.objects.filter(id=following).first() if not user_following: raise ValidationError({"detail": 'User does not exist'}) if user_following.is_public: data = { "follower": user, "following": following, "is_active": True } else: data = { "follower": user, "following": following, "is_active": False } serializer = FollowCreateSerializer(data=data) serializer.is_valid(raise_exception=True) serializer.save() if not user_following.is_public: new_notif = Notification(owner=user_following, text=request.user.username + " wants to follow you", date=datetime.now()) new_notif.save() return Response(serializer.data, status=200)
def persistNotif(notification): serializedAudience = " " for a in notification["audience"]: serializedAudience += (a + " ") notif = Notification(audience=serializedAudience, medium=notification["medium"], notif_type=notification["type"], params=json.dumps(notification["params"]), seen="") notif.save() notification['created_date'] = { "day": notif.created_date.day, "month": notif.created_date.month, "year": notif.created_date.year, "hour": notif.created_date.hour, "minute": notif.created_date.minute, "second": notif.created_date.second } notification['notif_id'] = notif.id notification['seen'] = notif.seen return notif
def upload_photo(request): if request.method == 'POST': sim_file= request.FILES['sim_id'] f=sim_file.read() sim_id=int(f) #test if Sim with number=sim_id exists if Sim.objects.filter(number = sim_id).count()==1: #Creating Photo object uploaded_photo = Photo(phototype= 'Blank', image = request.FILES['file_upload']) #Creating Notification object and save to DBB mySim=Sim.objects.get(number = sim_id) myBox=Box.objects.get(sim = mySim) if Notification.objects.filter(title__contains = uploaded_photo.image).count() > 1: i=0 for notification in Notification.objects.filter(title__contains = uploaded_photo.image): i+=1 titleu=str(uploaded_photo.image) + str(i) myNotification = Notification(title = titleu, box=myBox) else: myNotification = Notification(title = uploaded_photo.image, box=myBox) #Traitement d'image myNotification.save() #Polishing Photo object and save to DBB uploaded_photo.notification=myNotification uploaded_photo.save() #to remove str(sim_id) return HttpResponse("Image Uploaded, owner of sim_id = " + str(sim_id)) else: return HttpResponse("ACCESS DENIED: Box Not Identified") else: return HttpResponse("GET Denied")
def user_follow(sender, instance, *args, **kwargs): follow = instance sender = follow.follower following = follow.following notify = Notification(sender=sender, user=following, notification_type=3) notify.save()
def _post_async_submission(request, exercise, submission, errors=None): """ Creates or grades a submission. Required parameters in the request are points, max_points and feedback. If errors occur or submissions are no longer accepted, a dictionary with "success" is False and "errors" list will be returned. """ if not errors: errors = [] # The feedback field may contain null characters, which would invalidate # the form before its clean method is executed. So replace them beforehand. post_data = request.POST.copy() feedback = post_data.get('feedback') if feedback: post_data['feedback'] = feedback.replace('\x00', '\\x00') # Use form to parse and validate the request. form = SubmissionCallbackForm(post_data) errors.extend(extract_form_errors(form)) if not form.is_valid(): submission.feedback = _( "ERROR_ALERT_EXERCISE_ASSESSMENT_SERVICE_MALFUNCTIONING") submission.set_error() submission.save() if exercise.course_instance.visible_to_students: msg = "Exercise service returned with invalid grade request: {}"\ .format("\n".join(errors)) logger.error(msg, extra={"request": request}) email_course_error(request, exercise, msg, False) return {"success": False, "errors": errors} # Grade the submission. try: submission.set_points(form.cleaned_data["points"], form.cleaned_data["max_points"]) submission.feedback = form.cleaned_data["feedback"] submission.grading_data = post_data if form.cleaned_data["error"]: submission.set_error() else: submission.set_ready() submission.save() if form.cleaned_data["notify"]: Notification.send(None, submission) else: Notification.remove(submission) return {"success": True, "errors": []} # Produce error if something goes wrong during saving the points. except Exception as e: logger.exception("Unexpected error while saving grade" " for {} and submission id {:d}".format( str(exercise), submission.id)) return {"success": False, "errors": [repr(e)]}
def user_comment_post(sender, instance, *args, **kwargs): comment = instance post = comment.post text_preview = comment.body[:90] sender = comment.user notify = Notification(post=post, sender=sender, user=post.user, text_preview=text_preview, notification_type=2) notify.save()
def generateSuccessNotification(request): user = request.user bankingP = BankingPerson.objects.get(user=user) print bankingP.receiveSuccess if bankingP.receiveSuccess: n = Notification(title="Success may be on your way", text="hello world body", level = 1, to=user) n.save() return HttpResponseRedirect("/")
def add(request, post_id): if request.method == 'POST': post = Post.objects.get(id=post_id) account = Account.get_by_user(request.user) post.add_link(account) Notification.add(post.publisher, account, NotificationType.ADD, post) redirect_path = request.GET['next'] return redirect(redirect_path)
def envoyer_notification(self): try: bde = Association.objects.get(pseudo='bde') #On envoie seulement à ceux qui suivent le BDE notification = Notification(content_object=self, message='Un nouveau petit cours est disponible') notification.save() notification.envoyer_multiple(bde.suivi_par.all()) except Association.DoesNotExist: pass
def user_like_question(sender, instance, *args, **kwargs): like = instance question = like.question sender = like.auth notify = Notification(question=question, sender=sender, receiver=question.auth, notification_type=2) notify.save()
def user_add_answer(sender, instance, *args, **kwargs): ans = instance answer = ans.answer question = ans.question sender = ans.auth notify = Notification(answer=ans, question=question, sender=sender, receiver=ans.question.auth, notification_type=3) notify.save()
def user_like_answer(sender, instance, *args, **kwargs): like = instance ans = like.ans sender = like.auth notify = Notification(answer=ans, sender=sender, receiver=ans.auth, notification_type=1) notify.save()
def commentNotifction(sender, instance, created=None, **kwargs): print(instance.id, 'instalce ') if created: order = instance marchent = instance.marchant.user notify = Notification(order=order, marchent=marchent) notify.save()
def custompill_post(request): """ add new pill item for user <int:pk> """ if request.user.is_authenticated: # check if pill_id already exists in user's pills try: pill_data = json.loads(request.body.decode()) print(pill_data) take_method = pill_data['take_method'] product_name = pill_data['product_name'] expiration_date = pill_data['expiration_date'] functions = pill_data['functions'] print('error1') store_method = pill_data['store_method'] company_name = pill_data['company_name'] standards = pill_data['standards'] precautions = pill_data['precautions'] take_method_preprocessed = pill_data['take_method_preprocessed'] image_id = pill_data['image_id'] print('error') except (KeyError, ValueError): return HttpResponseBadRequest() existing_pills = request.user.pills.all().values_list('product_name', flat=True) if product_name in existing_pills: return HttpResponse(status=status.HTTP_400_BAD_REQUEST) print(pill_data) # get pill object from Pill model by id new_pill = CustomPill.objects.create( user=request.user, take_method=take_method, product_name=product_name, expiration_date=expiration_date, functions=functions, store_method=store_method, company_name=company_name, standards=standards, precautions=precautions, take_method_preprocessed=take_method_preprocessed, custom=True, ) # Assign pill to image image_instance = Image.objects.get(id=image_id) image_instance.pill = new_pill image_instance.user = request.user image_instance.save() # add retrieved pill object to current user's pills field request.user.pills.add(new_pill) # add notification for the new pill Notification.create(request.user, new_pill) return JsonResponse(get_pill_dict(new_pill), status=status.HTTP_201_CREATED) else: return HttpResponse(status=status.HTTP_401_UNAUTHORIZED)
def like_notification(sender, instance, *args, **kwargs): like = instance post = like.post sender = like.user notify = Notification(post=post, sender=sender, receiver=post.user, type='Like') notify.save()
def envoyer_notification(self, eleve): if eleve.user.associations_suivies.filter(pseudo='mediamines'): try: #Des gens ont peut etre deja été identifiés sur cette photo, il faut retrouver la notification notification = Notification.objects.get(content_type = ContentType.objects.get_for_model(self), object_id = self.id) notification.envoyer(eleve.user) except Notification.DoesNotExist: #En fait non, cette notification n'existe pas. On la crée. notification = Notification(content_object=self, message='Vous avez été identifié sur une photo de MediaMines') notification.save() notification.envoyer(eleve.user)
def team_req_join(request): # Get POST data teamHash = request.POST.get('team') # Try to decode the scrambled team pk try: teamPK = decode_value(teamHash) except Exception: print("bad hash") return JsonResponse({'status': 'ko'}) # Try to get the team try: team = get_object_or_404(Team, pk=teamPK) except Http404: print("team not found", teamPK) return JsonResponse({'status': 'ko'}) # Double check that the request does not already exist if Notification.objects.filter( user_from=request.user, user_to=team.author, foreignPK=teamPK, context=Notification.contexts.team.name, action=Notification.actions.team_req_join.name, read=False, ).exists(): print("Did exist") return JsonResponse({'status': 'ko'}) # Double check that the request does not already exist elif Notification.objects.filter( user_to=request.user, foreignPK=teamPK, context=Notification.contexts.team.name, action=Notification.actions.team_invite.name, read=False, ).exists(): print("Did exist") return JsonResponse({'status': 'ko'}) # Generate datahash print("Generating hash") notif_url = encode_data([request.user.pk, teamPK]) print(notif_url) # Generate a request notification notif_req = Notification( user_from=request.user, user_to=team.author, foreignPK=teamPK, context=Notification.contexts.team.name, action=Notification.actions.team_req_join.name, url=notif_url, ) notif_req.save() # Return a successful response return JsonResponse({'status': 'ok'})
def save(self, *args, **kwargs): markdown = Markdown() self.content_html = markdown.render(self.content) super().save(*args, **kwargs) from notification.models import Notification Notification.create_notifications_from_reply( reply=self, mentions=markdown.get_mentions() )
def find_mention_notifications(tweet): mentions = re.findall(r'@(\w*)', tweet.content) if mentions: for user in mentions: mentioned_user = TwitterUser.objects.filter(username=user).first() if mentioned_user: new_notification = Notification(intended_for=mentioned_user, tweet=tweet) new_notification.save()
def envoyer_notification(self): try: perm = Permission.objects.get(codename='add_sondage') #On envoie seulement à ceux qui peuvent créer des sondages users = User.objects.filter(Q(is_superuser=True) | Q(groups__permissions=perm) | Q(user_permissions=perm) ).distinct() notification = Notification(content_object=self, description='Un nouveau sondage a été proposé') notification.save() notification.envoyer_multiple(users) except Permission.DoesNotExist: pass
def _post_async_submission(request, exercise, submission, errors=None): """ Creates or grades a submission. Required parameters in the request are points, max_points and feedback. If errors occur or submissions are no longer accepted, a dictionary with "success" is False and "errors" list will be returned. """ if not errors: errors = [] # Use form to parse and validate the request. form = SubmissionCallbackForm(request.POST) errors.extend(extract_form_errors(form)) if not form.is_valid(): submission.feedback = _( "<div class=\"alert alert-error\">\n" "<p>The exercise assessment service is malfunctioning. " "Staff has been notified.</p>\n" "<p>This submission is now marked as erroneous.</p>\n" "</div>") submission.set_error() submission.save() if exercise.course_instance.visible_to_students: msg = "Exercise service returned with invalid grade request: {}"\ .format("\n".join(errors)) logger.error(msg, extra={"request": request}) email_course_error(request, exercise, msg, False) return {"success": False, "errors": errors} # Grade the submission. try: submission.set_points(form.cleaned_data["points"], form.cleaned_data["max_points"]) submission.feedback = form.cleaned_data["feedback"] submission.grading_data = request.POST if form.cleaned_data["error"]: submission.set_error() else: submission.set_ready() submission.save() if form.cleaned_data["notify"]: Notification.send(None, submission) else: Notification.remove(submission) return {"success": True, "errors": []} # Produce error if something goes wrong during saving the points. except Exception as e: logger.exception("Unexpected error while saving grade" " for {} and submission id {:d}".format( str(exercise), submission.id)) return {"success": False, "errors": [repr(e)]}
def follow(request, username): if request.method == 'POST': relationship = Relationship() relationship.owner = Account.get_by_user(request.user) relationship.follow = Account.get_by_username(username) if not relationship.owner.is_following(relationship.follow): relationship.save() Notification.add(relationship.follow, relationship.owner, NotificationType.FOLLOW) return redirect('profile', username)
def react(request, post_id): if request.method == 'POST': reaction = Reaction() reaction.post = Post.objects.get(id=post_id) reaction.owner = Account.get_by_user(request.user) reaction.save() Notification.add(reaction.post.owner, reaction.owner, NotificationType.REACT, reaction.post) redirect_path = request.GET['next'] return redirect(redirect_path)
def list(request): owner = request.user.accounts.first() notifications = Notification.objects.filter( owner=owner).order_by('-created_at') Notification.check_as_viewed(owner) notify_count = 0 return render(request, 'notification/list.html', { 'notifications': notifications, 'notify_count': notify_count })
def notify(self): # Guest confirmation Notification.notify('book_guest', { 'to_address': self.guest.email, 'meal': self, }) # Chef confirmation Notification.notify('book_chef', { 'to_address': self.kitchen.chef.email, 'meal': self, })
def setUp(self): self.user = factory.create_user('*****@*****.**', '*****@*****.**', 'john123', 'John', 'Doe') self.location = factory.create_location('Thailand', 'Nakhonsawan') self.category = factory.create_category('Travel', 'travel') self.blog = factory.create_blog('Travel in Nakhonsawan', self.user, self.category, self.location) self.love_user = factory.create_user('*****@*****.**', '*****@*****.**', 'adam123', 'Adam', 'Johnson') self.love_notification = Notification(subject=self.love_user, action=1, blog=self.blog) self.love_notification.save() self.download_notification = Notification(subject=self.user, action=2, blog=self.blog) self.download_notification.save()
def send_notification(request): params = request.POST client_id = params['client_id'] group_id = params['group_id'] title = params['title'] message = params['message'] target_url = params['target_url'] notification = Notification(title=title, message=message, target_url=target_url, client_id=client_id, group_id=group_id) notification.save() args = (user_list, title, message, target_url, notification_id) add_to_task(args, notification, client_id, group_id)
def post(self, request, goal_slug, suggestion_slug): # noqa self._get_data(request, goal_slug, suggestion_slug) if not self.review: self._create_review() data = ReviewSerializer(self.review).data data.update(request.data) serializer = ReviewSerializer(instance=self.review, data=data) if serializer.is_valid(): self.review = serializer.save(is_draft=False) update_rating_and_save(self.review.revision.suggestion) self.review.comments.filter(is_draft=False).delete() notification = Notification.create_for_review(self.review) if notification.owner != self.review.owner: notification.save() return Response( {'success': 1}, status=status.HTTP_200_OK ) else: return Response( { 'success': 0, 'errors': serializer.errors }, status=status.HTTP_200_OK )
def change_friend_status(request): if not request.user.is_authenticated(): return redirect(gethome()) if request.method != 'POST': print "NOT POST-----------------" return redirect(gethome()) else: print "CHANGE REQUEST ENTER AJAX CALL--------------------------" print request.POST notification_id = request.POST['this_id'] notification_object = Notification.objects.filter(notification_id=notification_id) response_type = str(request.POST['type']) if "delete_notification" == response_type: print "DELETe NOTIFICATION--------------------AJAX------------------" notification_object.delete() return redirect(gethome()) target_id = request.POST['target_id'] friend_object = Friends.objects.filter(friends_id=target_id) #-------------BETA-------------------------------------# user1_uuid = request.POST['user1_uuid'] user2_uuid = request.POST['user2_uuid'] #-------------BETA-------------------------------------# if "accept" == response_type: print "ACCEPT-------------------AJAX------------------" friend_object.update(status="F") notification_object.delete() #-------------BETA-------------------------------------# profile1 = Profile.objects.get(id=user1_uuid) profile2 = Profile.objects.get(id=user2_uuid) #-------------BETA-------------------------------------# message = str(profile2.first_name) + " " +str(profile2.last_name) +" " +"HAVE BECOME FRIENDS WITH YOU" accept_notification = Notification( user1=profile2.user, user2=profile1.user, message=message, user1_uuid=user2_uuid, user2_uuid=user1_uuid, notification_type="FA") accept_notification.save() elif "ignore" == response_type: print "IGNORE-------------------AJAX------------------" friend_object.delete() notification_object.delete() elif "block" == response_type: print "BLOCK--------------------AJAX------------------" return redirect(gethome())
def user_post_save(sender, instance, created, **kwargs): if created and not kwargs.get('raw', False): notification = Notification() notification.user = instance notification.save() address = Address() address.save(user=instance) profile = UserProfile() profile.user = instance profile.address = address profile.save() today = datetime.date.today() subscription = Subscription.objects.create(owner=instance, state=SUBSCRIPTION_STATE_TRIAL, expiration_date=today + datetime.timedelta(settings.TRIAL_DURATION), transaction_id='TRIAL-%i%i%i-%i' % (today.year, today.month, today.day, instance.id))
class TestHelperFunction(TestCase): def setUp(self): self.user = factory.create_user('*****@*****.**', '*****@*****.**', 'john123', 'John', 'Doe') self.location = factory.create_location('Thailand', 'Nakhonsawan') self.category = factory.create_category('Travel', 'travel') self.blog = factory.create_blog('Travel in Nakhonsawan', self.user, self.category, self.location) self.user_with_notification = factory.create_user('*****@*****.**', '*****@*****.**', 'adam123', 'Adam', 'Johnson') self.notification = Notification(subject=self.user_with_notification, action=1, blog=self.blog) self.notification.save() def tearDown(self): rm_user(self.user.id) rm_user(self.user_with_notification.id) self.notification.delete() def test_get_notifications(self): self.assertEqual(1, len(get_notifications(self.user))) self.assertEqual(0, len(get_notifications(self.user_with_notification)))
def upload_test(request): if request.method == 'POST': sim_id= request.POST['sim_id'] #test if Sim with number=sim_id exists if Sim.objects.filter(number = sim_id).count()==1: #Creating Photo object uploaded_photo = Photo(phototype= 'Blank', image = request.FILES['file_upload']) #Creating Notification object and save to DBB mySim=Sim.objects.get(number = sim_id) myBox=Box.objects.get(sim = mySim) if Notification.objects.filter(title__contains = uploaded_photo.image).count() > 1: i=0 for notification in Notification.objects.filter(title__contains = uploaded_photo.image): i+=1 titleu=str(uploaded_photo.image) + str(i) myNotification = Notification(title = titleu, box=myBox) else: myNotification = Notification(title = uploaded_photo.image, box=myBox) #Traitement d'image myNotification.save() #Polishing Photo object and save to DBB uploaded_photo.notification=myNotification uploaded_photo.save() #C:\Users\Elomario\Desktop\PI\Phase2\CMAIL-django\ #notificationu=Notification.objects.get(title='test recette') #photou=Photo.objects.get(notification=notificationu) print(str(uploaded_photo.image)) ls_fd = subprocess.Popen('static\SimpleColorDetection_TEST.exe ' + str(uploaded_photo.image),stdout=subprocess.PIPE).communicate()[0] print('done') out = ls_fd #ENDOFIMAGEHANDLING if "letter" in str(out): uploaded_photo.phototype='enveloppe' elif "colis" in str(out): uploaded_photo.phototype='colis' elif "pub" in str(out): uploaded_photo.phototype='pub' uploaded_photo.save() return HttpResponse("DO A POST " + str(out)) else: return HttpResponse("ACCESS DENIED: Box Not Identified")
def envoyer_message_notification(self): message = self.association.nom + " a publie un nouveau message" notification = Notification(content_object=self, message=message) notification.save() if self.destinataire is None: notification.envoyer_multiple(self.association.suivi_par.all()) else: recipients = self.association.suivi_par.all().filter( Q(userprofile__in=self.destinataire.membres.all) | Q(userprofile__in=self.association.membres.all) ) notification.envoyer_multiple(recipients)
def post(self, request): message={} if request.user.is_authenticated(): objectid=request.POST.get('objectid','') objecttype=request.POST.get('objecttype','') votetype=request.POST.get('votetype','') if objectid and objecttype and votetype: if objecttype=='question': currentobject=Question.objects.get(pk=objectid); elif objecttype=='answer': currentobject=Answer.objects.get(pk=objectid); if currentobject: if votetype=="vote": if request.user.profile in currentobject.votes.all(): message['status']='False' message['message']="Bạn chỉ được thích một lần" else: currentobject.votes.add(request.user.profile) currentobject.save() currentobject.author.rank+=0.01 currentobject.author.save() message['status']='OK' message['message']="" message['votes_count']=currentobject.votes_count elif votetype=="downvote": if request.user.profile in currentobject.downvotes.all(): message['status']='False' message['message']="Bạn chỉ được không thích một lần" else: currentobject.downvotes.add(request.user.profile) currentobject.save() currentobject.author.rank-=0.05 currentobject.author.save() message['status']='OK' message['message']="" message['votes_count']=currentobject.downvotes_count #notification if currentobject.author!=request.user.profile: notification=Notification() notification.action=votetype notification.sender=request.user.profile notification.recipient=currentobject.author notification.content_object=currentobject notification.save() else: message['status']='False' message['message']="{} không tồn tại".format(objecttype) else: message['status']='False' message['message']='Thông tin không chính xác' else: message['status']='False' message['message']='Bạn cần đăng nhập' return HttpResponse(json.dumps(message), content_type = "application/json")
def send_notification(request): params = request.POST client_id = params['client_id'] group_id = params['group_id'] title = params['title'] message = params['message'] target_url = params['target_url'] notification_date = params['date'] notification_time = params['time'] notification = Notification(title=title, message=message, target_url=target_url, client_id=client_id, group_id=group_id) notification.save() notification_id = notification.id user_list = get_notification_user_list(client_id, group_id) record_list = [NotificationResponse(user_id=user['id'], notification_id=notification_id) for user in user_list] NotificationResponse.objects.bulk_create(record_list) if notification_date!='' and notification_time!='': notification_eta = notification_date+' '+notification_time datetime_object = parser.parse(notification_eta) datetime_object = datetime_object.replace(tzinfo=None) + datetime_object.utcoffset() else: datetime_object = datetime.now() push_notification.apply_async(args=(user_list, title, message, target_url, notification_id), eta=datetime_object) return JsonResponse({'success': True})
def queue_notification(sender_id, recipient_id, model_name, obj_id): """ Adds a notification for an agree, thanks, bookmark, or follow. Increments the notification count in the cache. sender_id: agree.giver_id, thank.giver_id, bookmark.user_id, or backward.source_id recipient_id: agree.review.user_id, thank.review.user_id, 0, or backward.destination_id model_name: string of class name obj_id: object.pk """ model = get_model(MODEL_APP_NAME[model_name], model_name) try: pg_notification = Notification( sender=User.objects.get(pk=sender_id), recipient=User.objects.get(pk=recipient_id), notification_type=model_name ) if model_name == "agree" or model_name == "thank": obj = model.objects.get(pk=obj_id) pg_notification.item = obj.review.item if model_name == "thank": pg_notification.note = obj.note pg_notification.save() if not cacheAPI._get_new_notifications_count(recipient_id): cacheAPI._reset_new_notifications_count(recipient_id) cacheAPI._increment_new_notifications_count(recipient_id) cacheAPI._cache_notification_for_user(pg_notification) announce_client.emit( recipient_id, 'notification', data={ 'new': 1 } # Currently un-used ) except ObjectDoesNotExist: pass
def envoyer_commentaire_notification(self, comment_pk, username): eleve = UserProfile.objects.get(user__username=username) message = eleve.first_name + " " + eleve.last_name + " a commente un message de " + self.association.nom commentaire = Comment.objects.get(pk=comment_pk) notification = Notification(content_object=commentaire, message=message) notification.save() if self.destinataire is None: notification.envoyer_multiple(self.association.suivi_par.all()) else: recipients = self.association.suivi_par.all().filter( Q(userprofile__in=self.destinataire.membres.all) | Q(userprofile__in=self.association.membres.all) ) notification.envoyer_multiple(recipients)