def handle_noargs(self, **options):
self.stdout.write("Adofex-specific notice types\n")
for n in NOTICE_TYPES:
self.stdout.write("Creating %s\n" % n["label"])
notification.create_notice_type(n["label"], n["display"],
n["description"], n["default"])
self.stdout.write("Default set of notice types initialized successfully.\n")
def create_notice_types(self):
if "notification" in settings.INSTALLED_APPS:
from notification import models as notification
notification.create_notice_type("wall_new_comment_your_post", _("New Comment on Wall Post You Created"), _("someone has commented on your wall post"))
notification.create_notice_type("wall_new_comment_your_comment", _("New Comment on Wall Post You Commented On"), _("someone has commented on a wall post you commented on"))
else:
print "Skipping creation of NoticeTypes as notification app not found"
def create_notice_types(app, created_models, verbosity, **kwargs):
notices = (
("welcome", _("Welcome"),
_(u"welcome to Mozilla Badges")),
("badge_edited", _(u"Badge edited"),
_(u"one of your badges has been edited")),
("badge_awarded", _(u"Badge awarded"),
_(u"one of your badges has been awarded")),
("team_badge_management", _(u"Team badge created"),
_(u"a new badge has been added to a team you manage")),
("team_follower_badge_created", _(u"Team badge created"),
_(u"a team you follow has created a new badge")),
("award_received", _(u"Award received"),
_(u"you have been awarded a badge")),
("award_accepted", _(u"Badge award accepted"),
_(u"someone has accepted an award for one of your badges")),
("award_declined", _(u"Badge award declined"),
_(u"someone has declined an award for one of your badges")),
("nomination_submitted", _(u"Nomination submitted"),
_(u"someone has submitted a nomination for one of your badges")),
("nomination_approved", _(u"Nomination approved"),
_(u"a nomination you submitted for an award has been approved")),
("nomination_rejected", _(u"Nomination rejected"),
_(u"a nomination you submitted for an award has been rejected")),
("nomination_received", _(u"Nomination received"),
_(u"a nomination to award you a badge was approved")),
("nomination_accepted", _(u"Nomination accepted"),
_(u"a nomination you submitted for an award has been accepted")),
)
for notice in notices:
notification.create_notice_type(*notice)
def create_notice_types(app, created_models, verbosity, **kwargs):
notices = (
("welcome", _("Welcome"), _(u"welcome to Mozilla Badges")),
("badge_edited", _(u"Badge edited"),
_(u"one of your badges has been edited")),
("badge_awarded", _(u"Badge awarded"),
_(u"one of your badges has been awarded")),
("team_badge_management", _(u"Team badge created"),
_(u"a new badge has been added to a team you manage")),
("team_follower_badge_created", _(u"Team badge created"),
_(u"a team you follow has created a new badge")),
("award_received", _(u"Award received"),
_(u"you have been awarded a badge")),
("award_accepted", _(u"Badge award accepted"),
_(u"someone has accepted an award for one of your badges")),
("award_declined", _(u"Badge award declined"),
_(u"someone has declined an award for one of your badges")),
("nomination_submitted", _(u"Nomination submitted"),
_(u"someone has submitted a nomination for one of your badges")),
("nomination_approved", _(u"Nomination approved"),
_(u"a nomination you submitted for an award has been approved")),
("nomination_rejected", _(u"Nomination rejected"),
_(u"a nomination you submitted for an award has been rejected")),
("nomination_received", _(u"Nomination received"),
_(u"a nomination to award you a badge was approved")),
("nomination_accepted", _(u"Nomination accepted"),
_(u"a nomination you submitted for an award has been accepted")),
)
for notice in notices:
notification.create_notice_type(*notice)
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type(
"friends_invite", _("Invitation Received"),
_("you have received an invitation"))
notification.create_notice_type(
"friends_accept", _("Acceptance Received"),
_("an invitation you sent has been accepted"))
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type(
"tweet_follow", _("New Tweet Follower"),
_("someone has started following your tweets"))
notification.create_notice_type("tweet_reply_received",
_("New Tweet Reply"),
_("someone sent a tweet reply to you"))
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type("friendship_requested",
_("Friendship Requested"), _("you have received a friend request"),
default=2)
notification.create_notice_type("friendship_accepted",
_("Friendship Accepted"), _("your friend request was accepted"),
default=2)
def test_create_notice_type_with_same(self):
notice_type = create_notice_type("task new", "new task added", "task")
notice_type1 = create_notice_type("task new", "new task added11", "task")
notice_types = NoticeType.objects.filter(label=notice_type.label)
self.assertEqual(len(notice_types), 1)
notice_type.delete()
def create_notice_types(app, created_models, verbosity, **kwargs):
notices = (
("badge_edited", _(u"Badge edited"),
_(u"one of your badges has been edited")),
("badge_awarded", _(u"Badge awarded"),
_(u"one of your badges has been awarded to someone")),
("award_received", _(u"Award received"),
_(u"you have been awarded a badge")),
#("award_accepted", _(u"Badge award accepted"),
# _(u"someone has accepted an award for one of your badges")),
#("award_declined", _(u"Badge award declined"),
# _(u"someone has declined an award for one of your badges")),
# TODO: Notification on progress?
("nomination_submitted", _(u"Nomination submitted"),
_(u"someone has submitted a nomination for one of your badges")),
("nomination_approved", _(u"Nomination approved"),
_(u"a nomination you submitted for an award has been approved")),
("nomination_rejected", _(u"Nomination rejected"),
_(u"a nomination you submitted for an award has been rejected")),
("nomination_received", _(u"Nomination received"),
_(u"a nomination to award you a badge was approved")),
("nomination_accepted", _(u"Nomination accepted"),
_(u"a nomination you submitted for an award has been accepted")),
)
for notice in notices:
notification.create_notice_type(*notice)
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type("friends_invite", _("Invitation Received"), _("you have received an invitation"))
notification.create_notice_type("friends_accept", _("Acceptance Received"), _("an invitation you sent has been accepted"))
notification.create_notice_type("comment_receive", _("Comment Received"), _("you have received a comment"))
notification.create_notice_type("mentioned", _("Mentioned"), _("You have been mentioned"))
#so far, people can add friends without being approved
notification.create_notice_type("friends_add", _("Friend Added"), _("Someone added you as a friend"))
def create_notice_types(app, created_models, verbosity, **kwargs):
notices = (
("badge_edited", _("Badge edited"),
_("one of your badges has been edited")),
("badge_awarded", _("Badge awarded"),
_("one of your badges has been awarded to someone")),
("award_received", _("Award received"),
_("you have been awarded a badge")),
#("award_accepted", _("Badge award accepted"),
# _("someone has accepted an award for one of your badges")),
#("award_declined", _("Badge award declined"),
# _("someone has declined an award for one of your badges")),
# TODO: Notification on progress?
("nomination_submitted", _("Nomination submitted"),
_("someone has submitted a nomination for one of your badges")),
("nomination_approved", _("Nomination approved"),
_("a nomination you submitted for an award has been approved")),
("nomination_rejected", _("Nomination rejected"),
_("a nomination you submitted for an award has been rejected")),
("nomination_received", _("Nomination received"),
_("a nomination to award you a badge was approved")),
("nomination_accepted", _("Nomination accepted"),
_("a nomination you submitted for an award has been accepted")),
)
for notice in notices:
notification.create_notice_type(*notice)
def create_notice_type(self):
"""Create (or update) a notice type for discussion instance."""
create_notice_type(label=self.notification_label,
display=self.notification_display,
description="A new post has been added .",
slug=self._meta.app_label,
default=0)
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type(
'event_added',
_('Event Added'),
_('An event has been added'))
notification.create_notice_type(
'event_edited',
_('Event Edited'),
_('An event has been edited'))
notification.create_notice_type(
'event_deleted',
_('Event Deleted'),
_('An event has been deleted'))
notification.create_notice_type(
'event_registration_confirmation',
_('Event Registration Confirmation'),
_('The email you receive confirming your registration'))
notification.create_notice_type(
'event_registration_cancelled',
_('Event Registration Cancelled'),
_('Notify administrators that someone has cancelled their event registration'))
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type("distribution_fresh_list", _("Fresh List notice"), _("Here are the fresh foods available this week"), default=2)
notification.create_notice_type("distribution_pickup_list", _("Pickup List notice"), _("Here are the items to be picked up today"), default=2)
notification.create_notice_type("distribution_order_list", _("Order List notice"), _("Here are the orders to be delivered today"), default=2)
notification.create_notice_type("distribution_order_notice", _("Order Notice"), _("Here are the items ordered by this customer today"), default=2)
notification.create_notice_type("distribution_short_change_notice",
_("Short Change Notice"), _("Here are the short changes for this order"), default=2)
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type(
"new_favorite", _("New Favorite"),
_("Your project or comment has been favorited."))
notification.create_notice_type(
"new_follower", _("New Follower"),
_("You or your project has a new follower."))
def create_notice_types(app, created_models, verbosity, **kwargs):
# Notifications of stuff I'm doing
notification.create_notice_type("comment_posted",
_("Comment Posted"),
_("You have posted a comment"),
default=1)
notification.create_notice_type("comment_replied",
_("Comment Replied"),
_("You have replied to a comment"),
default=1)
# Notifications of stuff that concerns me directly
notification.create_notice_type(
"comment_reply_received",
_("Reply To Comment Received"),
_("You have received a reply to a comment"),
default=2)
# Notifications of stuff from my friends/users I'm following
notification.create_notice_type("comment_friend_posted",
_("Friend Posted Comment"),
_("A friend has posted a comment"),
default=1)
notification.create_notice_type("comment_friend_replied",
_("Friend Replied To Comment"),
_("A friend has replied to a comment"),
default=1)
def create_notice_types(app, created_models, verbosity, **kwargs):
"""
Create the announcement notice type for sending notifications when
announcements occur.
"""
notification.create_notice_type("announcement", "Announcement",
"you have received an announcement")
def sendMail_RegisterUser(senderuser,
receiveruser,
activity,
conjuction,
nid,
url=None):
nodeid = NID.objects.get(id=nid)
sys = nodeid.ref
if url == None:
url = sys.get_view_object_url
site = Site.objects.get_current()
render = render_to_string(
"/gstudio/notification/label.html", {
'sender': senderuser,
'activity': activity,
'conjunction': conjuction,
'object': sys.title,
'url': url,
'site': site
})
notification.create_notice_type(render, "Invitation Received",
"you have received an invitation")
notification.send(
receiveruser, render, {"from_user": senderuser}, sender=senderuser)
return
def sendMail_RegisterUser(senderuser,
receiveruser,
activity,
conjuction,
nid,
url=None):
nodeid = NID.objects.get(id=nid)
sys = nodeid.ref
if url == None:
url = sys.get_view_object_url
site = Site.objects.get_current()
render = render_to_string(
"/gstudio/notification/label.html", {
'sender': senderuser,
'activity': activity,
'conjunction': conjuction,
'object': sys.title,
'url': url,
'site': site
})
notification.create_notice_type(render, "Invitation Received",
"you have received an invitation")
notification.send(receiveruser,
render, {"from_user": senderuser},
sender=senderuser)
return
def create_notice_type(self):
"""Create (or update) a notice type for discussion instance."""
create_notice_type(
label=self.notification_label,
display=self.notification_display,
description="A new post has been added .",
slug=self._meta.app_label,
default=0)
def handle_noargs(self, **options):
self.stdout.write("Adofex-specific notice types\n")
for n in NOTICE_TYPES:
self.stdout.write("Creating %s\n" % n["label"])
notification.create_notice_type(n["label"], n["display"],
n["description"], n["default"])
self.stdout.write(
"Default set of notice types initialized successfully.\n")
def create_notice_types(sender, **kwargs):
print("Creating noticetypes for wiki ...")
notification.create_notice_type('wiki_revision_reverted',
_('Article Revision Reverted'),
_('your revision has been reverted'))
notification.create_notice_type(
'wiki_observed_article_changed', _('Observed Article Changed'),
_('an article you observe has changed'))
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type("presskitview_band_comment", _("band comment on presskit"), _("A band has commented a presskit view request"))
notification.create_notice_type("presskitview_venue_comment", _("venue comment on presskit"), _("A venue has commented a presskit view request"))
notification.create_notice_type("presskitview_accepted_by_venue", _("venue accepted to setup a gig"), _("A venue has accepted to set up a gig"))
notification.create_notice_type("presskitview_refused_by_venue", _("venue refused to setup a gig"), _("A venue has refused to set up a gig"))
notification.create_notice_type("presskitview_new", _("band proposed to set up gig to a venue"), _("A band has proposed to set up a gig"))
def handle(self, *args, **options):
notification.create_notice_type("create_meeting_slot", _("Meeting slot created"), _("your new slot is ready"))
notification.create_notice_type("reserved_meeting_slot", _("Meeting has been accepted"), _("your meeting has accepted"))
notification.create_notice_type("cancel_meeting", _("Meeting cancelled"), _("your meeting has been cancelled"))
notification.create_notice_type("pre_meeting_reminder", _("Your upcoming meeting"), _("your meetings starts in 24 hours"))
notification.create_notice_type("post_meeting_feedback_request", _("Let us know"), _("how did your meeting go?"))
self.stdout.write('--> Created notice types')
def post_init():
try:
for i in ALERT_INFO:
info = ALERT_INFO[i]
notification.create_notice_type(info['name'], info['short'],
info['long'])
except Exception, err:
logger.exception(err)
def test_create_notice_type_with_same(self):
notice_type = create_notice_type("task new", "new task added", "task")
notice_type1 = create_notice_type("task new", "new task added11",
"task")
notice_types = NoticeType.objects.filter(label=notice_type.label)
self.assertEqual(len(notice_types), 1)
notice_type.delete()
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type(
"new_reply", _("New reply"),
_("new reply to a post you're following"),
)
notification.create_notice_type(
"new_post", _("New post"),
_("new letter from an author or subject you're following"),
)
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type(
'usergroups_application', _("Application Received"),
_("someone has applied to join a "
"group"))
notification.create_notice_type(
'usergroups_application_approved', _("Application Approved"),
_("someone has approved an "
"application to join a group"))
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type(
"new_reply", _("New reply"),
_("new reply to a post you're following"),
)
notification.create_notice_type(
"new_post", _("New post"),
_("new letter from an author or subject you're following"),
)
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type('usergroups_application',
_("Application Received"),
_("someone has applied to join a "
"group"))
notification.create_notice_type('usergroups_application_approved',
_("Application Approved"),
_("someone has approved an "
"application to join a group"))
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type("exercise_create",
_("New exercise logged"),
_("a friend logged an exercise"),
default=1)
notification.create_notice_type(
"exercise_comment",
_("New Comment on Exercise"),
_("a comment was made on one of your exercises"),
default=2)
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type("messages_received",
_("Message Received"),
_("you have received a message"),
default=2)
notification.create_notice_type(
"messages_reply_received",
_("Reply Received"),
_("you have received a reply to a message"),
default=2)
def create_activity_types(app, created_models, verbosity, **kwargs):
if notification:
notification.create_notice_type("new_follower", _("New Follower"), _("somebody is following you now"), default=2)
try:
ActivityTypes.objects.get_or_create(name="started_following", batch_time_minutes=30, is_batchable=True)
ActivityTypes.objects.get_or_create(name="likes", is_batchable=False)
except:
pass
def send(receivers, type, info):
try:
notification.send(receivers, type, info)
except ObjectDoesNotExist:
notify_type = notification_types[type]
if notify_type:
notification.create_notice_type(type, _(notify_type[0]), _(notify_type[1]))
notification.send(receivers, type, info)
else:
logger.error("can't create notification type: %s" % type)
def create_activity_types(app, created_models, verbosity, **kwargs):
if notification:
notification.create_notice_type("new_follower", _("New Follower"), _("somebody is following you now"), default=2)
try:
ActivityTypes.objects.get_or_create(name="started_following", batch_time_minutes=30, is_batchable=True)
ActivityTypes.objects.get_or_create(name="likes", is_batchable=False)
except:
pass
def create_notice_types(sender, **kwargs):
print("Creating noticetypes for pybb ...")
notification.create_notice_type(
'forum_new_topic',
_('Forum New Topic'),
_('a new topic has been added to the forum'),
default=1)
notification.create_notice_type(
'forum_new_post', _('Forum New Post'),
_('a new comment has been posted to a topic you observe'))
def notifyactivity(request, activ, sys_id, userid):
print "activity =", activ
sys = ""
box = ""
if activ == "edited_thread":
print "edited thread"
ss = System.objects.filter(id=sys_id)
if ss:
sys = System.objects.get(id=sys_id)
box = sys.system_set.all()[0]
sysurl = str(sys.get_view_url)
else:
print "edited deleted", sys_id
ss = Gbobject.objects.filter(id=sys_id)
if ss:
print "inside ss"
ss = Gbobject.objects.get(id=int(sys_id))
if activ == "edited_twist":
sys = ss.getthread_of_twist
sysurl = "gstudio/" + str(show_nodesystem(sys.id))
box = get_threadbox_of_twist(int(sys_id))
elif activ == "deleted_response" or "added_response":
print "ss=", ss
systhd = ss.getthread_of_response
sys = systhd
if systhd:
box = systhd.system_set.all()[0]
sysurl = str(systhd.get_view_url)
sys_id = str(sys.id)
print box, "box"
if sys:
site = Site.objects.get_current()
render = render_to_string(
"/gstudio/notification/label.html",
{
"sender": request.user,
"activity": activ,
"conjunction": "\
-",
"object": sys.title,
"url": sysurl,
"site": site,
},
)
if box:
for bx in box.member_set.all():
notification.create_notice_type(render, "Invitation Received", "you have received an invitation")
notification.send([bx], render, {"from_user": request.user})
if activ == "edited_thread" or activ == "deleted_response" or activ == "added_response":
return HttpResponseRedirect("/gstudio/group/gnowsys-grp/" + sys_id)
elif activ == "edited_twist":
return HttpResponseRedirect("/gstudio/" + sysurl)
def notifyactivity(request, activ, sys_id, userid):
print "activity =", activ
sys = ""
box = ""
if activ == 'edited_thread':
print 'edited thread'
ss = System.objects.filter(id=sys_id)
if ss:
sys = System.objects.get(id=sys_id)
box = sys.system_set.all()[0]
sysurl = str(sys.get_view_url)
else:
print 'edited deleted', sys_id
ss = Gbobject.objects.filter(id=sys_id)
if ss:
print 'inside ss'
ss = Gbobject.objects.get(id=int(sys_id))
if activ == 'edited_twist':
sys = ss.getthread_of_twist
sysurl = 'gstudio/' + str(show_nodesystem(sys.id))
box = get_threadbox_of_twist(int(sys_id))
elif activ == 'deleted_response' or 'added_response':
print 'ss=', ss
systhd = ss.getthread_of_response
sys = systhd
if systhd:
box = systhd.system_set.all()[0]
sysurl = str(systhd.get_view_url)
sys_id = str(sys.id)
print box, "box"
if sys:
site = Site.objects.get_current()
render = render_to_string(
"/gstudio/notification/label.html", {
'sender': request.user,
'activity': activ,
'conjunction': '\
-',
'object': sys.title,
'url': sysurl,
'site': site
})
if box:
for bx in box.member_set.all():
notification.create_notice_type(
render, "Invitation Received",
"you have received an invitation")
notification.send([bx], render, {"from_user": request.user})
if activ == 'edited_thread' or activ == 'deleted_response' or activ == 'added_response':
return HttpResponseRedirect("/gstudio/group/gnowsys-grp/" + sys_id)
elif activ == 'edited_twist':
return HttpResponseRedirect("/gstudio/" + sysurl)
def create_notice_types(app, created_models, verbosity, **kwargs):
# Notifications of stuff I'm doing
notification.create_notice_type("comment_posted", _("Comment Posted"), _("you have posted a comment"), default=1)
notification.create_notice_type("comment_replied", _("Comment Replied"), _("you have replied to a comment"), default=1)
# Notifications of stuff that concerns me directly
notification.create_notice_type("comment_reply_received", _("Reply To Comment Received"), _("you have received a reply to a comment"), default=2)
# Notifications of stuff from my friends/users I'm following
notification.create_notice_type("comment_friend_posted", _("Friend Posted Comment"), _("a friend has posted a comment"))
notification.create_notice_type("comment_friend_replied", _("Friend Replied To Comment"), _("a friend has replied to a comment"))
def notifyuserunsubscribe(request,sys_id,userid):
sys=System.objects.get(id=sys_id)
box=sys.system_set.all()[0]
sysurl = str(sys.get_view_url)
site=Site.objects.get_current()
render = render_to_string("/gstudio/notification/label.html",{'sender':request.user,'activity':'UnSubscribed','conjunction':'from','object':sys.title,'url':sysurl,'site':site})
for bx in box.member_set.all():
notification.create_notice_type(render, "Invitation Received", "you have received an invitation")
notification.send([bx], render, {"from_user": request.user})
box.member_set.remove(Author.objects.get(id=userid))
return HttpResponseRedirect("/gstudio/group/gnowsys-grp/"+sys_id)
def create_notice_types(sender, **kwargs):
print('Creating wl specific noticetypes for django-messages ...')
notification.create_notice_type('messages_received',
_('Message Received'),
_('you have received a message'),
default=2)
notification.create_notice_type(
'messages_reply_received',
_('Reply Received'),
_('you have received a reply to a message'),
default=2)
def forwards(self, orm):
"Write your forwards methods here."
from django.conf import settings
from django.utils.translation import ugettext_noop as _
if "notification" in settings.INSTALLED_APPS:
from notification import models as notification
notification.create_notice_type("forum_subscription_reply", _("Subscription Reply"), _("new answer in topic that you subscribed"))
else:
print "Skipping creation of NoticeTypes as notification app not found"
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type(
"blog_friend_post",
_("Friend Posted to Blog"),
_("a friend of yours posted to their blog"),
default=2)
notification.create_notice_type(
"blog_post_comment",
_("New Comment on Blog Post"),
_("a comment was made on one of your blog posts"),
default=2)
def notifyuserunsubscribe(request,sys_id,userid):
sys=System.objects.get(id=sys_id)
box=sys.system_set.all()[0]
sysurl = str(sys.get_view_url)
site=Site.objects.get_current()
box.member_set.remove(Author.objects.get(id=userid))
render = render_to_string("/gstudio/notification/label.html",{'sender':request.user,'activity':'UnSubscribed','conjunction':'from','object':sys.title,'url':sysurl,'site':site})
for bx in box.member_set.all():
notification.create_notice_type(render, "Invitation Received", "you have received an invitation")
notification.send([bx], render, {"from_user": request.user})
return HttpResponseRedirect("/gstudio/group/gnowsys-grp/"+sys_id)
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type("friends_invite", _("Invitation Received"),
_("you have received an invitation"), default=2)
notification.create_notice_type("friends_invite_sent", _("Invitation Sent"),
_("you have sent an invitation"), default=1)
notification.create_notice_type("friends_accept", _("Acceptance Received"),
_("an invitation you sent has been accepted"), default=2)
notification.create_notice_type("friends_accept_sent", _("Acceptance Sent"),
_("you have accepted an invitation you received"),
default=1)
notification.create_notice_type("friends_otherconnect", _("Other Connection"),
_("one of your friends has a new connection"), default=2)
def forwards(self, orm):
"Write your forwards methods here."
from django.conf import settings
from django.utils.translation import ugettext_noop as _
if "notification" in settings.INSTALLED_APPS:
from notification import models as notification
notification.create_notice_type("tournaments_lineup_ready", _("Lineup ready"), _("both teams have submitted their lineup and it is ready to be viewed"))
notification.create_notice_type("tournaments_new_match", _("New match"), _("a new match has been created"))
else:
print "Skipping creation of NoticeTypes as notification app not found"
def create_notice_types(app, created_models, verbosity, **kwargs):
"""
Register notification types for django-notification.
"""
notification.create_notice_type(
'invitation',
_('Invitation received'),
_('you have received an invitation to collaborate in a problem'))
notification.create_notice_type(
'problem',
_('Problem updated'),
_('a problem you\'re contributing was updated'))
def register_plugin(plugin_dir):
from merengue.pluggable.models import RegisteredPlugin
from merengue.pluggable.utils import get_plugin_config, validate_plugin
plugin_config = get_plugin_config(plugin_dir)
if plugin_config:
validate_plugin(plugin_config)
try:
reg_plugin = RegisteredPlugin.objects.get_by_item_class(plugin_config)
except RegisteredPlugin.DoesNotExist:
reg_plugin = register(plugin_config)
plugin = reg_plugin.get_registry_item()
reg_plugin.name = getattr(plugin, 'name')
reg_plugin.directory_name = plugin_dir
reg_plugin.description = getattr(plugin, 'description', '')
reg_plugin.version = getattr(plugin, 'version', '')
reg_plugin.required_apps = getattr(plugin, 'required_apps',
None)
reg_plugin.required_plugins = getattr(plugin,
'required_plugins',
None)
reg_plugin.meta_info = {}
if hasattr(plugin, 'screenshot'):
reg_plugin.meta_info['screenshot'] = plugin.screenshot
reg_plugin.meta_info['actions'] = []
for action in plugin.get_actions():
reg_plugin.meta_info['actions'].append({'name': unicode(action.name), 'help_text': unicode(action.help_text)})
reg_plugin.meta_info['blocks'] = []
for block in plugin.get_blocks():
reg_plugin.meta_info['blocks'].append({'name': unicode(block.name), 'help_text': unicode(block.help_text)})
if plugin.get_model_admins():
reg_plugin.meta_info['has_own_admin'] = True
else:
reg_plugin.meta_info['has_own_admin'] = False
reg_plugin.meta_info['middlewares'] = []
for middleware in plugin.get_middlewares():
reg_plugin.meta_info['middlewares'].append(middleware)
reg_plugin.meta_info['section_models'] = []
for model, admin in plugin.section_models():
reg_plugin.meta_info['section_models'].append({'name': unicode(model._meta.verbose_name)})
reg_plugin.meta_info['viewlets'] = []
for viewlet in plugin.get_viewlets():
reg_plugin.meta_info['viewlets'].append({'name': unicode(viewlet.name), 'help_text': unicode(viewlet.help_text)})
if "notification" in settings.INSTALLED_APPS:
from notification.models import create_notice_type
for notification in plugin.get_notifications():
label, display, description = notification
create_notice_type(label, display, description)
reg_plugin.save()
return reg_plugin
return None
def create_notice_types(self):
if "notification" in settings.INSTALLED_APPS:
from notification import models as notification
notification.create_notice_type(
"wall_new_comment_your_post",
_("New Comment on Wall Post You Created"),
_("someone has commented on your wall post"))
notification.create_notice_type(
"wall_new_comment_your_comment",
_("New Comment on Wall Post You Commented On"),
_("someone has commented on a wall post you commented on"))
else:
print "Skipping creation of NoticeTypes as notification app not found"
def create_notice_types(app, created_models, verbosity, **kwargs):
notices = (
("badge_edited", _("Badge edited"), _("one of your badges has been edited")),
("badge_awarded", _("Badge awarded"), _("one of your badges has been awarded to someone")),
("award_received", _("Award received"), _("you have been awarded a badge")),
# ("award_accepted", _("Badge award accepted"),
# _("someone has accepted an award for one of your badges")),
# ("award_declined", _("Badge award declined"),
# _("someone has declined an award for one of your badges")),
# TODO: Notification on progress?
)
for notice in notices:
notification.create_notice_type(*notice)
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type(
"new_event", "New Event", "an employer you're subscribed to has created a new event"
)
notification.create_notice_type("public_invite", "Event Invite", "an employer has invited you to an event")
notification.create_notice_type("private_invite", "Private Event Invite", "an employer has invited you to an event")
notification.create_notice_type("cancelled_event", "Cancelled Event", "an employer has cancelled an event")
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type("friends_invite",
_("Invitation Received"),
_("you have received an invitation"))
notification.create_notice_type(
"friends_accept", _("Acceptance Received"),
_("an invitation you sent has been accepted"))
notification.create_notice_type("comment_receive",
_("Comment Received"),
_("you have received a comment"))
notification.create_notice_type("mentioned", _("Mentioned"),
_("You have been mentioned"))
#so far, people can add friends without being approved
notification.create_notice_type("friends_add", _("Friend Added"),
_("Someone added you as a friend"))
def sendNotify(pageid,senderUsername,recieverUsername,response_content):
sys=System.objects.filter(id=pageid)
if sys:
sys=System.objects.get(id=pageid)
else:
sys=Gbobject.objects.get(id=pageid)
#sysurl=str(sys.get_view_url)
page=sys.title
objurl=sys.get_view_object_url
activ=response_content
#print response_content,pageid,userid,username,activ
site=Site.objects.get_current()
render = render_to_string("/gstudio/notification/label.html",{'sender':username,'activity':activ,'conjunction':'-','object':page,'site':site,'oburl':objurl})
bx=Author.objects.get(username=recieverUsername)
notification.create_notice_type(render, "Notification", "notification")
notification.send([bx], render, {"from_user": username})
def create_notice_types(app, created_models, verbosity, **kwargs):
notices = (
("badge_edited", _("Badge edited"),
_("one of your badges has been edited")),
("badge_awarded", _("Badge awarded"),
_("one of your badges has been awarded to someone")),
("award_received", _("Award received"),
_("you have been awarded a badge")),
#("award_accepted", _("Badge award accepted"),
# _("someone has accepted an award for one of your badges")),
#("award_declined", _("Badge award declined"),
# _("someone has declined an award for one of your badges")),
# TODO: Notification on progress?
)
for notice in notices:
notification.create_notice_type(*notice)
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type("subscription_created",
_("WISePhone Subscription"),
_("Your WISePhone Subscription has been recorded."))
notification.create_notice_type("subscription_update",
_("Subscription Update Request Received"),
_("Subscription update request has been accepted"))
notification.create_notice_type("subscription_revoke",
_("Subscription Revoked"),
_("Your subscription has been revoked"))
notification.create_notice_type("subscription_expiration_warning",
_("Expiration Warning"),
_("Your WISePhone Subscription will expire soon"))
notification.create_notice_type("subscription_expired",
_("Notice of expiration"),
_("Your WISePhone Subscription has expired"))
def setUp(self):
self.user = DjangoUser.objects.create_user(username="******",
password="******")
self.notice_type = create_notice_type("task_new", "new task added",
"task")
self.client = Client()
self.client.login(username=self.user.username,
password=self.user.username)
def create_notice_types(app, created_models, verbosity, **kwargs):
notification.create_notice_type(
'new_event', 'New Event',
"an employer you're subscribed to has created a new event")
notification.create_notice_type('public_invite', 'Event Invite',
'an employer has invited you to an event')
notification.create_notice_type('private_invite', 'Private Event Invite',
'an employer has invited you to an event')
notification.create_notice_type('cancelled_event', 'Cancelled Event',
'an employer has cancelled an event')
def notifyactivity(request,activ,sys_id,userid):
print "activity =",activ
sys=""
box=""
if activ=='edited_thread':
print 'edited thread'
ss=System.objects.filter(id=sys_id)
if ss:
sys=System.objects.get(id=sys_id)
box=sys.system_set.all()[0]
sysurl=str(sys.get_view_url)
else:
print 'edited deleted',sys_id
ss=Gbobject.objects.filter(id=sys_id)
if ss:
print 'inside ss'
ss=Gbobject.objects.get(id=int(sys_id))
if activ=='edited_twist':
sys=ss.getthread_of_twist
sysurl='gstudio/'+str(show_nodesystem(sys.id))
box=get_threadbox_of_twist(int(sys_id))
elif activ=='deleted_response'or 'added_response':
print 'ss=',ss
systhd=ss.getthread_of_response
sys=systhd
if systhd:
box=systhd.system_set.all()[0]
sysurl=str(systhd.get_view_url)
sys_id=str(sys.id)
print box,"box"
if sys:
site=Site.objects.get_current()
render = render_to_string("/gstudio/notification/label.html",{'sender':request.user,'activity':activ,'conjunction':'\
-','object':sys.title,'url':sysurl,'site':site})
if box:
for bx in box.member_set.all():
notification.create_notice_type(render, "Invitation Received", "you have received an invitation")
notification.send([bx], render, {"from_user": request.user})
if activ=='edited_thread' or activ=='deleted_response' or activ=='added_response':
return HttpResponseRedirect("/gstudio/group/gnowsys-grp/"+sys_id)
elif activ=='edited_twist':
return HttpResponseRedirect("/gstudio/"+sysurl)
