def notify(sender, receptors, message, url, level=1, **kwargs): """ receptors: list of user instances """ notifications = [] receptor_emails = [] for receptor in receptors: notification = Notification( sender=sender, receptor=receptor, message=message, url=url, level=level, ) notification.save() notifications.append(notification) receptor_emails.append(receptor.email) if level < EMAIL_THRESHOLD: send_mail(message, url, sender.email, receptor_emails, fail_silently=False) return notifications
def get(self, page=None): current_user_object = self.get_current_user_object() if not page: page = 1 page = int(page) mentions_marshalled = [] mentions = Notification.mentions_for_user(current_user_object.id, int(page)) mentions_count = Notification.mentions_for_user_count( current_user_object.id) url_format = '/mentions/%d' for mention in mentions: c = Comment.get('id = %s and deleted = 0', mention.action_id) if c: sf = Sharedfile.get('id = %s and deleted = 0', c.sharedfile_id) if sf: mentions_marshalled.append({ 'comment': c, 'sharedfile': sf, }) # this clears all mentions. When you visit this page ns = Notification.where('type=%s and receiver_id=%s and deleted=0', 'mention', current_user_object.id) [n.delete() for n in ns] return self.render("conversations/mentions.html", mentions=mentions_marshalled, count=mentions_count, \ page=page, url_format=url_format, selected='mentions')
def post(self, shake_name=None): shake = Shake.get('name=%s', shake_name) current_user_object = self.get_current_user_object() requestor = User.get('id = %s', self.get_argument('user_id', None)) if not shake: raise tornado.web.HTTPError(404) if not requestor: if self.get_argument('json', None): return self.write({'status':'error'}) else: return self.redirect('/%s', shake.name) no = Notification.get('sender_id = %s and receiver_id = %s and action_id = %s and deleted = 0', requestor.id, current_user_object.id, shake.id) if not no: if self.get_argument('json', None): return self.write({'status':'error'}) else: return self.redirect('/%s' % (shake.name)) no.delete() if self.get_argument('json', None): return self.write({'status':'ok', 'count' : Notification.count_for_user_by_type(current_user_object.id, 'invitation_request')}) else: return self.redirect('/%s' % (shake.name))
def post(self, comment_id): session = get_current_session() if session.has_key('user'): message = helper.sanitizeHtml(self.request.get('message')) user = session['user'] if len(message) > 0: try: parentComment = db.get(comment_id) comment = Comment(message=message, user=user, post=parentComment.post, father=parentComment) comment.put() comment.post.remove_from_memcache() vote = Vote(user=user, comment=comment, target_user=user) vote.put() Notification.create_notification_for_comment_and_user( comment, parentComment.user) self.redirect('/noticia/' + str(parentComment.post.key())) except db.BadKeyError: self.redirect('/') else: self.redirect('/responder/' + comment_id) else: self.redirect('/login')
def post(self, post_id): session = get_current_session() if session.has_key('user'): message = helper.sanitizeHtml(self.request.get('message')) user = session['user'] if len(message) > 0: try: post = Post.all().filter( 'nice_url =', helper.parse_post_id(post_id)).get() if post == None: #If for some reason the post doesn't have a nice url, we try the id. This is also the case of all old stories post = db.get(helper.parse_post_id(post_id)) post.remove_from_memcache() comment = Comment(message=message, user=user, post=post) comment.put() vote = Vote(user=user, comment=comment, target_user=user) vote.put() Notification.create_notification_for_comment_and_user( comment, post.user) self.redirect('/noticia/' + post_id) except db.BadKeyError: self.redirect('/') else: self.redirect('/noticia/' + post_id) else: self.redirect('/login')
def _invitations(shake, current_user): invitation = None invitation_requests = [] if current_user: notification = Notification.invitation_to_shake_for_user( shake, current_user) if notification: sender = notification.sender() related_object = notification.related_object() invitation = { 'sender': sender, 'related_object': related_object, 'id': notification.id } if current_user and current_user.id == shake.user_id: notifications = Notification.where( 'type = %s and receiver_id = %s and action_id = %s and deleted = 0', 'invitation_request', current_user.id, shake.id) if notifications: for notification in notifications: sender = notification.sender() related_object = notification.related_object() invitation_requests.append({ 'sender': sender, 'related_object': related_object, 'id': notification.id }) return ( invitation, invitation_requests, )
class NotificationTestCase(CoreTestCase): def setUp(self): super(NotificationTestCase, self).setUp() self._create() def _create(self): self.subject = random_string(25) self.message = random_string(35) self.notification = Notification( user=self.user, subject=self.subject, message=self.message ) self.notification.save() def test_can_list(self): response = self.client.get(reverse_lazy('notification.list')) self.assertEqual(response.status_code, 200) count = Notification.objects.filter(user=self.user).count() self.assertEqual(len(response.context['object_list']), count) def test_can_show_detail(self): self._create() url = reverse_lazy('notification.detail', args=[self.notification.id]) response = self.client.get(url) self.assertEqual(response.context['object'].subject, self.notification.subject) self.assertEqual(response.context['object'].read, True)
def post(self): if self.request.get('notification-route-entity-key'): user = users.get_current_user() email = user.email().lower() receiver = self.request.get('notification-contact') if str(self.request.get('daily-notification')) == "on": notification_type = 1 else: notification_type = 0 route_key = ndb.Key( urlsafe=str(self.request.get('notification-route-entity-key'))) route = route_key.get() route_time = route.start_time notification_time = route_time - datetime.timedelta(hours=int( self.request.get("notification-hour"))) - datetime.timedelta( minutes=int(self.request.get("notification-minute"))) new_notification = Notification(parent=route_key, creator=email, receiver=receiver, time=notification_time, type=notification_type, message="") new_notification.put() notification_utils.add_notification_to_task_queue(new_notification) self.redirect('/'.join(self.request.referer.split("/")[:3]) + "?route=" + str(route.key.urlsafe())) else: self.redirect('/')
def post(self, request): data = request.POST timestamp = timezone.now() if 'oid' in data and data['oid'] and validate_oid(data['oid']): OID = data['oid'] else: return HttpResponseBadRequest('Error: No valid OID provided') if 'iped' in data and data['iped'] and get_school(data['iped']): school = get_school(data['iped']) if not school.contact: errmsg = "Error: School has no contact." return HttpResponseBadRequest(errmsg) if Notification.objects.filter(institution=school, oid=OID): errmsg = "Error: OfferID has already generated a notification." return HttpResponseBadRequest(errmsg) notification = Notification(institution=school, oid=OID, timestamp=timestamp, errors=data['errors'][:255]) notification.save() msg = notification.notify_school() callback = json.dumps({'result': 'Verification recorded; {0}'.format(msg)}) response = HttpResponse(callback) return response else: errmsg = ("Error: No school found") return HttpResponseBadRequest(errmsg)
def post(self, request, *args, **kwargs): user_id = kwargs['user_id'] sender = request.user.customuser user = CustomUser.objects.get(pk=user_id) if user == sender: raise HttpResponseForbidden("Can't add itself.") user_friends = user.friends.all() sender_notifications = sender.notification.all() if sender not in user_friends: # make notification only when adding first n = Notification(user=user, source=sender) n.save() else: # delete already generated notification for sender m = "" for notif in sender_notifications: if notif.source == user: m = notif if not m == "": m.delete() sender.friends.add(user) sender.save() c = user_context(user, sender) return render(request, self.template_name, c)
def post(self, post_id): session = get_current_session() if session.has_key('user'): message = helper.sanitizeHtml(self.request.get('message')) user = session['user'] key = self.request.get('comment_key') if len(message) > 0 and key == keys.comment_key: try: post = Post.all().filter('nice_url =', helper.parse_post_id( post_id ) ).get() if post == None: #If for some reason the post doesn't have a nice url, we try the id. This is also the case of all old stories post = db.get( helper.parse_post_id( post_id ) ) post.remove_from_memcache() comment = Comment(message=message,user=user,post=post) comment.put() helper.killmetrics("Comment","Root", "posted", session, "",self) vote = Vote(user=user, comment=comment, target_user=user) vote.put() Notification.create_notification_for_comment_and_user(comment,post.user) self.redirect('/noticia/' + post_id) except db.BadKeyError: self.redirect('/') else: self.redirect('/noticia/' + post_id) else: self.redirect('/login')
def create_user(): if not session.get('user_id'): flash("You need to be logged in to do that.", category="danger") return redirect(url_for('main.home')) user = User.query.filter_by(id=session['user_id']).one() if user.type != 1: flash("You need administrator priveledges to do that.", category="danger") return redirect(url_for('main.home')) form = CreateUserForm(request.form) random_password = str(uuid.uuid4())[:8] if request.method=="POST" and form.validate(): newUser = User(type=int(form.admin.data), password=random_password, username=form.username.data, email=form.email.data) if User.query.filter_by(username=newUser.username).all(): flash("A user with that username already exists!", category="danger") elif User.query.filter_by(email=newUser.email).all(): flash("A user with that email already exists!", category="danger") else: db.session.add(newUser) db.session.commit() registered_notification = Notification(newUser.id, None, "PlantSpeak Registration Details", """You have successfully signed up for PlantSpeak. Your login details are as follows: USERNAME: %s PASSWORD %s""" % (newUser.username, random_password), newUser.email) registered_notification.send() flash("User created successfully!", category="success") return redirect(url_for('main.home')) return render_template("create_user.html", form=form)
def get(self): session = get_current_session() if session.has_key('user'): user = session['user'] page = helper.sanitizeHtml(self.request.get('pagina')) perPage = 10 page = int(page) if page else 1 realPage = page - 1 inboxAll = True if realPage > 0: prevPage = realPage if (page * perPage) < Notification.all().filter( "target_user ="******"target_user ="******"-created").fetch(perPage, perPage * realPage) prefetch.prefetch_refprops(notifications, Notification.post, Notification.comment, Notification.sender_user) self.response.out.write( template.render('templates/notifications.html', locals())) else: self.redirect('/login')
def dashboard(): """ The '/dashboard' route directs a user to view their dashboard. """ if 'username' in session: if not session['type_of_user'] == "user": return render_template("access_denied.html") info = User.get_user_info(session['username']) if (info == None): return render_template("dashboard.html", first_name=" ") first_name = info['first_name'] # Get notifications for this user. unread = Notification.get_number_of_unread(session['username']) notifications = Notification.get_notif_to_recipient( session['username'], 5) # If the user has no projects in history, they are a new user. user_type = User.get_user_info(session['username'])['type_of_user'] recs = { "client_rec_des": "Most Active Clients", "dev_rec_des": "Most Active Developers", "client_rec": Client.get_most_active_clients(), "dev_rec": Developer.get_most_active_developers() } if user_type == 'client': if Client.get_info( session['username'])['num_of_completed_projects'] > 0: recs = { "client_rec_des": "Clients with Similar Interests", "dev_rec_des": "Developers with Similar Interests", "client_rec": Client.get_similar_clients(session['username']), "dev_rec": Developer.get_similar_developers(session['username']) } elif user_type == 'developer': if Developer.get_info( session['username'])['num_of_completed_projects'] > 0: recs = { "client_rec_des": "Clients with Similar Interests", "dev_rec_des": "Developers with Similar Interests", "client_rec": Client.get_similar_clients(session['username']), "dev_rec": Developer.get_similar_developers(session['username']) } return render_template("dashboard.html", first_name=first_name, notifications=notifications, recs=recs, unread=unread) else: return redirect(url_for('login'))
def setUpTestData(cls): admin = User.objects.get(pk=1) group_foo = User.objects.filter(groups__name='group_foo') staff = User.objects.get_by_natural_key('staff') cls.admin_user = admin cls.n2_admin = Notification.send( [admin], 'test notification to admin', 'fa-info', Notification.COLOR_DANGER, url='http://www.google.com/' ) cls.n2_staff = Notification.send( [staff], 'test notifications to staff', 'fa-bell', Notification.COLOR_DANGER, ) cls.n2_group_foo = Notification.send( group_foo, 'test notifications to client', 'fa-bell', Notification.COLOR_WARNING, '' )
def push_user_notification(self, event_uuid, team_id, user_id): ''' Push to one user ''' if team_id in self.notify_connections and user_id in self.notify_connections[team_id]: json = Notification.by_event_uuid(event_uuid).to_json() for wsocket in self.notify_connections[team_id][user_id]: wsocket.write_message(json) Notification.delivered(wsocket.user_id, event_uuid)
def notify_user( notification_type, user=None, follower=None, photo=None): notification = Notification(notification_type=notification_type, user=follower, photo=photo) notification.save() user_notification = UserNotifications.objects.get(user=user) user_notification.notifications.add(notification) user_notification.save() return
def delete(id): entity = Notification.get(id) if(entity is None): raise ValueError("Notification does not exists") else: entity.active = False Notification.save(entity)
def save(entity): if entity.key is None: if not entity.notification_status: entity.notification_status = "unread" if not (entity.notification_status == "read" or entity.notification_status == "unread"): raise ValueError("notification_status can be only 'read' or 'unread'") entity = Notification.save(entity) else: if not (entity.notification_status == "read" or entity.notification_status == "unread"): raise ValueError("notification_status can be only 'read' or 'unread'") current = Notification.get(entity.key.urlsafe()) if current is not None: current.company_key = entity.company_key current.user_key = entity.user_key current.notification_text = entity.notification_text current.notification_params = entity.notification_params current.notification_status = entity.notification_status current.notification_type = entity.notification_type entity = Notification.save(entity) else: raise ValueError("Notification does not exists") return entity
def create_introduction_notification(user): """ """ subject = "Welcome to Groupr" body = "Anything is possible at Groupr. The infinite is possible at Groupr. The unattainable is unknown at Groupr. This Groupr. This is Groupr." new_notif = Notification(recipient=user, subject=subject, text=body) new_notif.save()
def mark_notifications_as_read(user_id: int): if user_id != g.user.id: abort(403) array_ids = validate_notifications_list_form(request.json) responses_array = [] response_status = None for notification_id in array_ids: notification = Notification.get_notification_by_id( notification_id) if notification is None: notif_status = 404 elif notification.user_id != user_id: notif_status = 403 else: notification.mark_as_read() notif_status = 200 responses_array.append({ 'id': notification_id, 'status': notif_status }) if response_status == 207 or response_status == notif_status: pass elif response_status is None: response_status = notif_status else: response_status = 207 user = User.get_user_by_id(user_id) notifications = Notification.get_notifications_by_user(user) return jsonify({ "notifications": [notification.as_dict() for notification in notifications] })
def test_clears_all_subscriptions(self): user3 = User(name="user3", email="*****@*****.**", email_confirmed=1) user3.set_password('asdfasdf') user3.save() Subscription(user_id=self.sender.id, shake_id=2).save() Subscription(user_id=user3.id, shake_id=2).save() Notification.new_subscriber(self.sender, self.receiver, 1) Notification.new_subscriber(user3, self.receiver, 2) request = HTTPRequest( self.get_url('/account/clear-notification'), 'POST', {'Cookie': '_xsrf=%s;sid=%s' % (self.xsrf, self.receiver_sid)}, '_xsrf=%s&type=subscriber' % (self.xsrf)) self.http_client.fetch(request, self.stop) response = self.wait() j = json_decode(response.body) self.assertEqual(j['response'], "You have 0 new followers") ns = Notification.where('receiver_id=%s' % (self.receiver.id)) for n in ns: self.assertTrue(n.deleted)
def post(self, request): data = request.POST timestamp = timezone.now() if 'oid' in data and data['oid'] and validate_oid(data['oid']): OID = data['oid'] else: return HttpResponseBadRequest('Error: No valid OID provided') if 'iped' in data and data['iped'] and get_school(data['iped']): school = get_school(data['iped']) if not school.contact: errmsg = "Error: School has no contact." return HttpResponseBadRequest(errmsg) if Notification.objects.filter(institution=school, oid=OID): errmsg = "Error: OfferID has already generated a notification." return HttpResponseBadRequest(errmsg) notification = Notification(institution=school, oid=OID, timestamp=timestamp, errors=data['errors'][:255]) notification.save() msg = notification.notify_school() callback = json.dumps( {'result': 'Verification recorded; {0}'.format(msg)}) response = HttpResponse(callback) return response else: errmsg = ("Error: No school found") return HttpResponseBadRequest(errmsg)
def push_user_notification(self, event_uuid, team_id, user_id): ''' Push to one user ''' if team_id in self.notify_connections and user_id in self.notify_connections[ team_id]: json = Notification.by_event_uuid(event_uuid).to_json() for wsocket in self.notify_connections[team_id][user_id]: wsocket.write_message(json) Notification.delivered(wsocket.user_id, event_uuid)
def notify(course, user_id): course_id = course.course_id favs = course.favourite_by usernames = [fav.user_id for fav in favs] for username in usernames: if username != user_id: notify = Notification(user_id=username, course_id=course_id) notify.insert()
def reject_project(request, project_id): proj = Project.objects.get(id=int(project_id)) new_notification = Notification(recipient=proj.client, subject="Project Rejected", text="The instructor decided that your project '{}' submission was not right for the" \ " scope of the course and has decided not to allow students to bid on it.".format(proj.name)) new_notification.save() proj.delete() return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def test_deleting_favorite_notification(self): notification = Notification.new_favorite(sender=self.user2, sharedfile=self.sharedfile) sent_notification = Notification.get("id=%s", notification.id) sent_notification.delete() check_delete_notification = Notification.get("id=%s", notification.id) self.assertTrue(check_delete_notification.deleted)
def reject_bid(request, bid_id): bid = Bid.objects.get(id=int(bid_id)) new_notification = Notification(recipient=bid.student, subject="Bid Rejected", text="Your bid on the project '{}' was rejected by your instructors." \ " Please browse and continue submitting more bids.".format(bid.project.name)) new_notification.save() bid.delete() return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def reject_bid(request, bid_id): bid = Bid.objects.get(id=int(bid_id)) new_notification = Notification(recipient=bid.student, subject="Bid on {} Rejected".format(bid.project.name), text="Your bid on the project {} was rejected by your instructor(s)." \ "Please continue browsing and submitting more bids.") new_notification.save() bid.delete() return redirect_user_to_homepage(request.user.profile.user_type)
def award_bid(request, bid_id): bid = Bid.objects.get(id=int(bid_id)) new_notification = Notification(recipient=bid.student, subject="Bid on {} Awarded!".format(bid.project.name), text="Your bid on the project {} was awarded by your instructor(s)!" \ "This will be your project. Contact your client at {}".format(bid.project.name, bid.project.client.email)) new_notification.save() bid.delete() return redirect_user_to_homepage(request.user.profile.user_type)
def push_team_notification(self, event_uuid, team_id): ''' Push to one team ''' json = Notification.by_event_uuid(event_uuid).to_json() if team_id in self.notify_connections: for user_id in self.notify_connections[team_id].keys(): for wsocket in self.notify_connections[team_id][user_id]: wsocket.write_message(json) Notification.delivered(wsocket.user_id, event_uuid)
def like(id, *args, **kwargs): currentUser = User.get().filter_by(id=kwargs['token']['id']).first() post = Post.get().filter_by(id=id).first() like = Post_Likes.get().filter( and_(Post_Likes.author == currentUser.id, Post_Likes.post == post.id)).first() not_id = str(db.session.execute(Sequence('notification_id_seq'))) if like is not None: response = jsonify({'operation': 'disliked'}) like.delete() body = 'unliked your post' else: response = jsonify({'operation': 'liked'}) new_like = Post_Likes(post=post.id, author=currentUser.id) new_like.add() body = 'liked your post' not_check = Notification.get().filter_by(title=currentUser.name + ' ' + body).filter_by( body=post.title).first() if not_check is None: notify = Notification( id=int(not_id), author=currentUser.id, user=post.author.id, type=2, title=post.title, body=currentUser.name + ' ' + body, link='/post/' + (str(post.title).replace(' ', '-')).replace('?', '') + '-' + str(post.id) + '?notification_id=' + not_id) notify.add() else: not_check.checked = False not_check.save() if post.author.status != 2: send_notification( post.author.id, { 'text': currentUser.name + ' ' + body, 'link': '/post/' + (str(post.title).replace(' ', '-')).replace('?', '') + '-' + str(post.id), 'icon': currentUser.info.avatar_img, 'id': not_id }) socket.emit("notification", room="notification-{}".format(post.author.id)) return make_response(response, 200)
def notification(request): ''' View responsible for receiving a notification from PagSeguro and make a query to update the Payment. ''' incoming_notification = Notification(code=request.POST['notificationCode']) incoming_notification.save() start_new_thread(incoming_notification.check, tuple()) return HttpResponse("OK", mimetype="text/plain")
def send_notification(): form = SendNotificationForm() if form.validate_on_submit(): noti = Notification() noti.content = form.notification.data db.session.add(noti) db.session.commit() return redirect(url_for('notify.send_notification'))
def post(self): notification = Notification( item_cl = Model.get(Key(self.request.get('key'))), message = self.request.get('message'), user = users.User(self.request.get('email')), is_cl = ("True" == self.request.get('is_cl')), time = datetime.now(), read = False) notification.put()
def notifyusers(userstonotify, parkingid): for user in userstonotify: notification = Notification() notification.userid = user message = "Your spot at " + str(parkingid) + " has been occupied" notification.message = message texthere(User.query.filter(User.id == user).first().phoneno, message) db.session.add(notification) db.session.commit()
def create_notification(text, entity, acting_user=None, recipient = None): try: notification = Notification(text = text, entity = entity, acting_user = acting_user, recipient=recipient) notification.save() return HttpResponse(_('Notification create successfully')) except: resp = HttpResponse(str(sys.exc_info()[1])) resp.status_code = 500 return resp
def notification(request): """ View responsible for receiving a notification from PagSeguro and make a query to update the Payment. """ incoming_notification = Notification(code=request.POST["notificationCode"]) incoming_notification.save() start_new_thread(incoming_notification.check, tuple()) return HttpResponse("OK", mimetype="text/plain")
def _create(self): self.subject = random_string(25) self.message = random_string(35) self.notification = Notification( user=self.user, subject=self.subject, message=self.message ) self.notification.save()
def push_broadcast_notification(self, event_uuid): ''' Push to everyone ''' json = Notification.by_event_uuid(event_uuid).to_json() for team_id in self.notify_connections.keys(): for user_id in self.notify_connections[team_id].keys(): for wsocket in self.notify_connections[team_id][user_id]: wsocket.write_message(json) if wsocket.user_id != '$public_user': Notification.delivered(user_id, event_uuid)
def create_notification(notification: Notification) -> JSONResponse: """ Adds a new notification. :param notification: the notification to add :return: status code and response data """ db = _get_db() notification.notification_id = db["notifications"].find().count() + 1 _get_db()["notifications"].insert_one(notification.to_dict()) return JSONResponse(status_code=status.HTTP_201_CREATED, content=dumps([]))
def alert(users, notify_type, subject, url): '''Assesses whether or not a user's settings allow a notification, and creates a "smart link" notification if allowed ''' users_permitting = (user for user in users if notify_type in user.notify_permissions) for user in users_permitting: n = Notification(recip=user, subject=subject, _url=url) n.save()
def test_send_notification_to_group(self): """ Tests that notification is sent to group. """ group=Group.objects.get(name="test_group") notification = Notification(text="There is a new story in discussion", \ group=group) notification.save() # Test that one message has been sent. self.assertEquals(len(mail.outbox), len([user for user in User.objects.all() if group in user.groups.all()]))
def test_send_notification_to_user(self): """ Tests that notification is sent to user. """ notification = Notification(text="There is a new story in discussion", \ recipient = User.objects.get(username="******"), \ group = Group.objects.get(name="test_group")) notification.save() # Test that one message has been sent. self.assertEquals(len(mail.outbox), 1)
def push_broadcast_notification(self, event_uuid): ''' Push to everyone ''' json = Notification.by_event_uuid(event_uuid).to_json() for team_id in self.notify_connections: for user_id in self.notify_connections[team_id]: for wsocket in self.notify_connections[team_id][user_id]: wsocket.write_message(json) # Only mark delivered for non-public users if wsocket.user_id != '$public_user': Notification.delivered(user_id, event_uuid)
def test_new_save_notification(self): notification = Notification.new_save(sender=self.user2, sharedfile=self.sharedfile) sent_notification = Notification.get("id=%s", notification.id) self.assertEqual(sent_notification.id, notification.id) self.assertEqual(sent_notification.sender_id, self.user2.id) self.assertEqual(sent_notification.receiver_id, self.user.id) self.assertEqual(sent_notification.action_id, 1) self.assertEqual(sent_notification.type, 'save')
def push_broadcast_notification(self, event_uuid): """ Push to everyone """ json = Notification.by_event_uuid(event_uuid).to_json() for team_id in self.notify_connections: for user_id in self.notify_connections[team_id]: for wsocket in self.notify_connections[team_id][user_id]: wsocket.write_message(json) # Only mark delivered for non-public users if wsocket.user_id != "$public_user": Notification.delivered(user_id, event_uuid)
def notificate_registry(new_user): users = User.objects.filter(is_superuser=True) for user in users: notification = Notification( user=user, message="El cliente "+new_user.first_name+" "+new_user.last_name+" se ha registrado en la plataforma.", short="Nuevo registro", icon="fa fa-user" ) notification.save()
def newNotification(values): try: print values auxNotification = Notification(to=values["to"], _from=values["from"], send_date=values["send_date"], \ activity=values["activity"], message=values["message"], title=values["title"]) auxNotification.save() return True except DatabaseError as e: return False except IntegrityError as e: return False
def get_approval_notice(self): notice = Notification( channel=self, target=self.target, text="%s wants to send you notifications. Click here to approve/deny this request." % self.source.source_name, ) notice.title = "New Notification Source" notice.link = "http://%s/sources" % WWW_HOST notice.icon = self.source.source_icon notice.sticky = "true" return notice
def notify_group(notification_type, group=None, photowalk=None): notification = Notification(notification_type=notification_type, group=group, photowalk=photowalk) if notification_type is 'group': to_notify = group.members.all() elif notification_type is 'photowalk': to_notify = photowalk.participants.all() notification.save() for user in to_notify: user_notification = UserNotifications.objects.get(user=user) user_notification.notifications.add(notification) user_notification.save() return
def test_seen(self): seen_befor = self.n2_admin[0].seen self.assertEqual( seen_befor, False ) Notification.seen_all(self.admin_user) seen_after = Notification.objects.get(pk=self.n2_admin[0].pk).seen self.assertEqual( seen_after, True )
def __create__(cls, user, title, message, category, event_uuid, icon=None): ''' Create a notification and save it to the database ''' notification = Notification( user_id=user.id, event_uuid=event_uuid, title=unicode(title), message=unicode(message), category=category, ) if icon is not None: notification.icon = icon dbsession.add(notification) dbsession.flush()
def __anonymous__(cls, title, message, category, event_uuid, icon=None): ''' Creates anonysmous notification where user_id = NULL ''' notification = Notification( user_id=None, event_uuid=event_uuid, title=unicode(title), message=unicode(message), category=category, ) if icon is not None: notification.icon = icon dbsession.add(notification) dbsession.flush()
def notify(request, app, model, id, action): band = request.band ct = ContentType.objects.get(app_label=app, model=model) try: obj = ct.get_object_for_this_type(id=id) except: message = _("%(model)s with id %(id)s does not exist" % dict(model=model, id=id)) return dict(success=False, message=message) users = band.active_members notes = request.POST.get('notes') or None mail = request.POST.get('mail') or False Notification.notify(obj, action, users, notes=notes, mail=mail) return dict(success=True)
def notify_user(message): user = User.objects.get(id=int(message['user_id'])) related_user = User.objects.get(id=int(message['related_user_id'])) nc = user.notification_config(message['notification_type']) if nc.take_action: notification = Notification(user=user, type_id=notification_types[message['notification_type']], related_user=related_user, seen=not nc.notify, **message['data']) notification.save(only_if_should_notify=True, host_url=message['host_url']) if nc.email and message['host_url']: Channel('email_notification').send({ 'notification_id': notification.id, 'host_url': message['host_url'] })
def persist_message(self, msg): notification = Notification() notification.sender = msg.sender notification.owner = users.User(utils.address_part(msg.sender)) # TODO: Handle invalid delays delay = utils.email_in_path(self.request.path) notification.delay_str = delay notification.fire_time = datetime.datetime.now() + utils.parse_timedelta(delay) strip_cc(msg) try: strip_attachments(msg) except Exception, e: logging.warning('Found warning ' + str(e)) pass
def post(self): action = self.request.get('action') if action == 'delete': notice = Notification.get_by_hash(self.request.get('notification')) if self.account.key() == notice.target.key(): notice.delete() self.redirect('/history')
def post(self): action = self.request.get("action") if action == "delete": notice = Notification.get_by_hash(self.request.get("notification")) if self.account.key() == notice.target.key(): notice.delete() self.redirect("/history")
def get_notifications(self,tree_name=None,from_username=None): data = None if tree_name is not None: data = Notification.get_all_by_tree_name(tree_name) elif from_username is not None: data = Notification.get_all_by_from_username(from_username) elif self.current_user_info() is not None: #default to the users inbox data = Notification.get_all_by_to_username(self.current_user_info().username) else: return False, [ 'unauthenticated' ] if data is not None: return True, data else: #if we could not get to the default, then the user must be logged out return False, [ ]