def feedback(request):
"""
"""
if request.method == "POST":
form = FeedbackForm(request.user, data=request.POST)
if form.is_valid():
context = {
'user': request.user,
'email': request.user.is_authenticated() and request.user.email or form.cleaned_data.get('email', None),
'message': form.cleaned_data['message'],
'name': request.user.is_authenticated() and request.user.username or form.cleaned_data.get('name', None),
'ip': request.META['REMOTE_ADDR'],
}
recipients = User.objects.filter(is_superuser=True)
send_template_email(recipients, "notifications/feedback.html", context)
msg = _('Thanks for the feedback!')
request.user.message_set.create(message=msg, level=messages_extends.SUCCESS_PERSISTENT)
return HttpResponseRedirect(get_next_url(request))
else:
form = FeedbackForm(request.user, initial={'next':get_next_url(request)})
return render_to_response('feedback.html', {'form': form}, context_instance=RequestContext(request))
def send_validation_email(request):
if not request.user.is_authenticated():
return HttpResponseUnauthorized(request)
else:
# We check if there are some old validation hashes. If there are -- we delete them.
try:
hash = ValidationHash.objects.get(user=request.user, type="email")
hash.delete()
except:
pass
# We don't care if there are previous cashes in the database... In every case we have to create a new one
hash = ValidationHash.objects.create_new(request.user, "email", [request.user.email])
additional_get_params = urllib.urlencode(request.GET)
send_template_email(
[request.user],
"auth/mail_validation.html",
{"validation_code": hash, "additional_get_params": additional_get_params},
)
request.user.message_set.create(
message=_("A message with an email validation link was just sent to your address.")
)
return HttpResponseRedirect(request.META.get("HTTP_REFERER", "/"))
def question_posted(action, new):
question = action.node
if not question.is_notifiable:
return
subscribers = User.objects.filter(
Q(subscription_settings__enable_notifications=True, subscription_settings__new_question='i') |
(Q(subscription_settings__new_question_watched_tags='i') &
Q(marked_tags__name__in=question.tagnames.split(' ')) &
Q(tag_selections__reason='good'))
).exclude(id=question.author.id).distinct()
subscribers = filter_subscribers(subscribers)
send_template_email(subscribers, "notifications/newquestion.html", {'question': question})
subscription = QuestionSubscription(question=question, user=question.author)
subscription.save()
new_subscribers = User.objects.filter(
Q(subscription_settings__all_questions=True) |
Q(subscription_settings__all_questions_watched_tags=True,
marked_tags__name__in=question.tagnames.split(' '),
tag_selections__reason='good'))
for user in new_subscribers:
create_subscription_if_not_exists(question, user)
def comment_posted(action, new):
comment = action.node
post = comment.parent
question = comment.abs_parent
answers = comment.author.get_visible_answers(question)
if not comment.is_notifiable or not post.is_notifiable:
return
if post.__class__ == Question:
question = post
else:
question = post.question
q_filter = Q(subscription_settings__notify_comments=True) | Q(subscription_settings__notify_comments_own_post=True, id=post.author.id)
inreply = re.search('@\w+', comment.comment)
if inreply is not None:
q_filter = q_filter | Q(subscription_settings__notify_reply_to_comments=True,
username__istartswith=inreply.group(0)[1:],
nodes__parent=post, nodes__node_type="comment")
subscribers = question.subscribers.filter(
q_filter, subscription_settings__subscribed_questions='i', subscription_settings__enable_notifications=True
).exclude(id=comment.user.id).distinct()
subscribers = filter_subscribers(subscribers)
send_template_email(subscribers, "notifications/newcomment.html", {'comment': comment})
create_subscription_if_not_exists(question, comment.user)
def question_posted(action, new):
question = action.node
if not question.is_notifiable:
return
subscribers = User.objects.filter(
Q(subscription_settings__enable_notifications=True,
subscription_settings__new_question='i')
| (Q(subscription_settings__new_question_watched_tags='i')
& Q(marked_tags__name__in=question.tagnames.split(' '))
& Q(tag_selections__reason='good'))).exclude(
id=question.author.id).distinct()
subscribers = filter_subscribers(subscribers)
send_template_email(subscribers, "notifications/newquestion.html",
{'question': question})
subscription = QuestionSubscription(question=question,
user=question.author)
subscription.save()
new_subscribers = User.objects.filter(
Q(subscription_settings__all_questions=True)
| Q(subscription_settings__all_questions_watched_tags=True,
marked_tags__name__in=question.tagnames.split(' '),
tag_selections__reason='good'))
for user in new_subscribers:
create_subscription_if_not_exists(question, user)
def request_temp_login(request):
if request.method == 'POST':
form = TemporaryLoginRequestForm(request.POST)
if form.is_valid():
users = form.user_cache
for u in users:
if u.is_suspended():
return forward_suspended_user(request, u, False)
for u in users:
try:
hash = get_object_or_404(ValidationHash, user=u, type='templogin')
if hash.expiration < datetime.datetime.now():
hash.delete()
return request_temp_login(request)
except:
hash = ValidationHash.objects.create_new(u, 'templogin', [u.id])
send_template_email([u], "auth/temp_login_email.html", {'temp_login_code': hash})
request.user.message_set.create(message=_("An email has been sent with your temporary login key"))
return HttpResponseRedirect(reverse('index'))
else:
form = TemporaryLoginRequestForm()
return render_to_response(
'auth/temp_login_request.html', {'form': form},
context_instance=RequestContext(request))
def feedback(request):
if request.method == "POST":
form = FeedbackForm(request.user, data=request.POST)
if form.is_valid():
context = {
'user':
request.user,
'email':
request.user.is_authenticated() and request.user.email
or form.cleaned_data.get('email', None),
'message':
form.cleaned_data['message'],
'name':
request.user.is_authenticated() and request.user.username
or form.cleaned_data.get('name', None),
'ip':
request.META['REMOTE_ADDR'],
}
recipients = User.objects.filter(is_superuser=True)
send_template_email(recipients, "notifications/feedback.html",
context)
msg = _('Thanks for the feedback!')
request.user.message_set.create(message=msg)
return HttpResponseRedirect(get_next_url(request))
else:
form = FeedbackForm(request.user,
initial={'next': get_next_url(request)})
return render_to_response('feedback.html', {'form': form},
context_instance=RequestContext(request))
def comment_posted(action, new):
comment = action.node
post = comment.parent
if not comment.is_notifiable or not post.is_notifiable:
return
if post.__class__ == Question:
question = post
else:
question = post.question
q_filter = Q(subscription_settings__notify_comments=True) | Q(subscription_settings__notify_comments_own_post=True, id=post.author.id)
inreply = re.search('@\w+', comment.comment)
if inreply is not None:
q_filter = q_filter | Q(subscription_settings__notify_reply_to_comments=True,
username__istartswith=inreply.group(0)[1:],
nodes__parent=post, nodes__node_type="comment")
subscribers = question.subscribers.filter(
q_filter, subscription_settings__subscribed_questions='i', subscription_settings__enable_notifications=True
).exclude(id=comment.user.id).distinct()
subscribers = filter_subscribers(subscribers)
send_template_email(subscribers, "notifications/newcomment.html", {'comment': comment})
create_subscription_if_not_exists(question, comment.user)
def request_temp_login(request):
if request.method == 'POST':
form = TemporaryLoginRequestForm(request.POST)
if form.is_valid():
users = form.user_cache
for u in users:
if u.is_suspended():
return forward_suspended_user(request, u, False)
for u in users:
try:
hash = get_object_or_404(ValidationHash, user=u, type='templogin')
if hash.expiration < datetime.datetime.now():
hash.delete()
return request_temp_login(request)
except:
hash = ValidationHash.objects.create_new(u, 'templogin', [u.id])
send_template_email([u], "auth/temp_login_email.html", {'temp_login_code': hash})
request.user.message_set.create(message=_("An email has been sent with your temporary login key"))
return HttpResponseRedirect(reverse('index'))
else:
form = TemporaryLoginRequestForm()
return render_to_response(
'auth/temp_login_request.html', {'form': form},
context_instance=RequestContext(request))
def send_validation_email(request):
if not request.user.is_authenticated():
return HttpResponseUnauthorized(request)
else:
# We check if there are some old validation hashes. If there are -- we delete them.
try:
hash = ValidationHash.objects.get(user=request.user, type='email')
hash.delete()
except:
pass
# We don't care if there are previous cashes in the database... In every case we have to create a new one
hash = ValidationHash.objects.create_new(request.user, 'email',
[request.user.email])
additional_get_params = urllib.urlencode(
dict([k, v.encode('utf-8')] for k, v in request.GET.items()))
send_template_email(
[request.user], "auth/mail_validation.html", {
'validation_code': hash,
'additional_get_params': additional_get_params
})
request.user.message_set.create(message=_(
"A message with an email validation link was just sent to your address."
))
return HttpResponseRedirect(
request.META.get('HTTP_REFERER', reverse('index')))
def ask(request):
form = None
if request.POST:
if request.session.pop('reviewing_pending_data', False):
form = AskForm(initial=request.POST, user=request.user)
elif "text" in request.POST:
form = AskForm(request.POST, user=request.user)
if form.is_valid():
if request.user.is_authenticated(
) and request.user.email_valid_and_can_ask():
ask_action = AskAction(
user=request.user,
ip=request.META['REMOTE_ADDR']).save(
data=form.cleaned_data)
question = ask_action.node
if settings.WIKI_ON and request.POST.get('wiki', False):
question.nstate.wiki = ask_action
if "expert_email" in form.cleaned_data:
email = form.cleaned_data["expert_email"].split()
u = User(username=_("Friend"), email=email)
send_template_email([u],
"notifications/newquestion.html", {
'question': question,
"exclude_finetune": True
})
return HttpResponseRedirect(question.get_absolute_url())
else:
request.session[PENDING_SUBMISSION_SESSION_ATTR] = {
'POST': request.POST,
'data_name': _("question"),
'type': 'ask',
'submission_url': reverse('ask'),
'time': datetime.datetime.now()
}
if request.user.is_authenticated():
request.user.message_set.create(
message=_("Your question is pending until you %s.")
% html.hyperlink(reverse('send_validation_email'),
_("validate your email")))
return HttpResponseRedirect(reverse('index'))
else:
return HttpResponseRedirect(reverse('auth_signin'))
elif "go" in request.POST:
form = AskForm({'title': request.POST['q']}, user=request.user)
if not form:
form = AskForm(user=request.user)
return render_to_response('ask.html', {
'form': form,
'tab': 'ask'
},
context_instance=RequestContext(request))
def handle_noargs(self, **options):
try:
translation.activate(settings.LANGUAGE_CODE)
except:
logging.error(
"Unable to set the locale in the send emails cron job")
digest_control = EMAIL_DIGEST_FLAG.value
if digest_control is None:
digest_control = {
'LAST_DAILY':
datetime.datetime.now() - datetime.timedelta(days=1),
'LAST_WEEKLY':
datetime.datetime.now() - datetime.timedelta(days=1),
}
from_date = digest_control['LAST_DAILY']
digest_control['LAST_DAILY'] = datetime.datetime.now()
EMAIL_DIGEST_FLAG.set_value(digest_control)
users = User.objects.filter(
subscription_settings__enable_notifications=True,
subscription_settings__send_digest=True)
# Send digest only to active users
if settings.SEND_DIGEST_ONLY_TO_ACTIVE_USERS:
users = users.filter(is_active=True)
# Send digest only to users with validated emails
if settings.SEND_DIGEST_ONLY_TO_VALIDATED_USERS:
users = users.filter(email_isvalid=True)
new_members = User.objects.filter(
is_active=True, date_joined__gt=from_date).annotate(
n_actions=models.Count('actions')).order_by('-n_actions')
new_member_count = new_members.count()
# The number of the flagged content for the day
flagged_count = Flag.objects.filter(
flagged_at__gt=datetime.datetime.today() -
datetime.timedelta(days=1)).count()
if new_member_count >= SHOW_N_MORE_ACTIVE_NEW_MEMBERS:
new_members = new_members[:SHOW_N_MORE_ACTIVE_NEW_MEMBERS]
show_all_users = True
else:
show_all_users = False
digest = DigestQuestionsIndex(from_date)
if (not new_member_count) and (not digest.count):
return
send_template_email(users, "notifications/digest.html", locals())
def test_email_settings(request):
user = request.user
send_template_email([user,], 'osqaadmin/mail_test.html', { 'user' : user })
return render_response(
'osqaadmin/test_email_settings.html',
{ 'user': user, },
request, parent_template="base.html")
def member_joined(action, new):
subscribers = User.objects.filter(
subscription_settings__enable_notifications=True,
subscription_settings__member_joins='i'
).exclude(id=action.user.id).distinct()
subscribers = filter_subscribers(subscribers)
send_template_email(subscribers, "notifications/newmember.html", {'newmember': action.user})
def member_joined(action, new):
subscribers = User.objects.filter(
subscription_settings__enable_notifications=True,
subscription_settings__member_joins='i'
).exclude(id=action.user.id).distinct()
subscribers = filter_subscribers(subscribers)
send_template_email(subscribers, "notifications/newmember.html", {'newmember': action.user})
def process_action(self):
all_superusers = User.objects.filter(is_superuser=True)
send_template_email(all_superusers, "notifications/user_reported.html", {
'reported': self.extra['reported'],
'user': self.user,
'message': self.extra['publicmsg']
}
)
def handle_noargs(self, **options):
try:
translation.activate(settings.LANGUAGE_CODE)
except:
logging.error("Unable to set the locale in the send emails cron job")
digest_control = EMAIL_DIGEST_FLAG.value
if digest_control is None:
digest_control = {
"LAST_DAILY": datetime.datetime.now() - datetime.timedelta(days=1),
"LAST_WEEKLY": datetime.datetime.now() - datetime.timedelta(days=1),
}
from_date = digest_control["LAST_DAILY"]
digest_control["LAST_DAILY"] = datetime.datetime.now()
EMAIL_DIGEST_FLAG.set_value(digest_control)
users = User.objects.filter(
subscription_settings__enable_notifications=True, subscription_settings__send_digest=True
)
# Send digest only to active users
if settings.SEND_DIGEST_ONLY_TO_ACTIVE_USERS:
users = users.filter(is_active=True)
# Send digest only to users with validated emails
if settings.SEND_DIGEST_ONLY_TO_VALIDATED_USERS:
users = users.filter(email_isvalid=True)
new_members = (
User.objects.filter(is_active=True, date_joined__gt=from_date)
.annotate(n_actions=models.Count("actions"))
.order_by("-n_actions")
)
new_member_count = new_members.count()
# The number of the flagged content for the day
flagged_count = Flag.objects.filter(
flagged_at__gt=datetime.datetime.today() - datetime.timedelta(days=1)
).count()
if new_member_count >= SHOW_N_MORE_ACTIVE_NEW_MEMBERS:
new_members = new_members[:SHOW_N_MORE_ACTIVE_NEW_MEMBERS]
show_all_users = True
else:
show_all_users = False
digest = DigestQuestionsIndex(from_date)
if (not new_member_count) and (not digest.count):
return
send_template_email(users, "notifications/digest.html", locals())
def process_action(self):
all_superusers = User.objects.filter(is_superuser=True)
send_template_email(
all_superusers, "notifications/user_reported.html", {
'reported': self.extra['reported'],
'user': self.user,
'message': self.extra['publicmsg']
})
def test_email_settings(request):
user = request.user
send_template_email([
user,
], 'osqaadmin/mail_test.html', {'user': user})
return render_to_response('osqaadmin/test_email_settings.html', {
'user': user,
}, RequestContext(request))
def test_email_settings(request):
user = request.user
send_template_email([user,], 'osqaadmin/mail_test.html', { 'user' : user })
return render_to_response(
'osqaadmin/test_email_settings.html',
{ 'user': user, },
RequestContext(request)
)
def answer_accepted(action, new):
question = action.node.question
subscribers = question.subscribers.filter(
subscription_settings__enable_notifications=True,
subscription_settings__subscribed_questions='i'
).exclude(id=action.node.nstate.accepted.by.id).distinct()
subscribers = filter_subscribers(subscribers)
send_template_email(subscribers, "notifications/answeraccepted.html", {'answer': action.node})
def process_action(self):
hash = ValidationHash.objects.create_new(self.user, 'email', [self.user.email])
send_template_email([self.user], "auth/welcome_email.html", {'validation_code': hash})
info=weibo_get(self.user,"users/show")
if info is not None:
weibo_post(self.user,_("i have joined the %(app_name)s, comming together! %(url)s") % {
'app_name':settings.APP_SHORT_NAME,
'url':settings.APP_URL,
})
self.user.weibo_gravatar=info["avatar_hd"]
self.user.use_weibo_gravatar=True
self.user.save()
def send_validation_email(request):
if not request.user.is_authenticated():
return HttpResponseUnauthorized(request)
else:
try:
hash = ValidationHash.objects.get(user=request.user, type='email')
hash.delete()
except:
hash = ValidationHash.objects.create_new(request.user, 'email', [request.user.email])
send_template_email([request.user], "auth/mail_validation.html", {'validation_code': hash})
request.user.message_set.create(message=_("A message with an email validation link was just sent to your address."))
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def ask_to_me(request, uid, uname):
form = None
if request.POST:
if request.session.pop('reviewing_pending_data', False):
form = AskForm(initial=request.POST, user=request.user)
elif "text" in request.POST:
form = AskForm(request.POST, user=request.user)
if form.is_valid():
if request.user.is_authenticated() and request.user.email_valid_and_can_ask():
ask_action = AskAction(user=request.user, ip=request.META['REMOTE_ADDR']).save(data=form.cleaned_data)
question = ask_action.node
if settings.WIKI_ON and request.POST.get('wiki', False):
question.nstate.wiki = ask_action
if "expert_email" in form.cleaned_data:
email = form.cleaned_data["expert_email"].split()
u = User(username = _("Friend"), email = email)
send_template_email([u], "notifications/newquestion.html", {'question': question, "exclude_finetune": True})
return HttpResponseRedirect(question.get_absolute_url())
else:
request.session[PENDING_SUBMISSION_SESSION_ATTR] = {
'POST': request.POST,
'data_name': _("question"),
'type': 'ask',
'submission_url': reverse('ask'),
'time': datetime.datetime.now()
}
if request.user.is_authenticated():
request.user.message_set.create(message=_("Your question is pending until you %s.") % html.hyperlink(
reverse('send_validation_email'), _("validate your email")
))
return HttpResponseRedirect(reverse('index'))
else:
return HttpResponseRedirect(reverse('auth_signin'))
elif "go" in request.POST:
form = AskForm({'title': request.POST['q']}, user=request.user)
if not form:
try:
expert = User.objects.get( id = uid)
except Exception, e:
try:
expert = User.objects.get(username = uname)
except Exception, e:
return HttpResponseRedirect(reverse("ask"))
def answer_posted(action, new):
answer = action.node
question = answer.question
subscribers = question.subscribers.filter(
subscription_settings__enable_notifications=True,
subscription_settings__notify_answers=True,
subscription_settings__subscribed_questions='i'
).exclude(id=answer.author.id).distinct()
subscribers = filter_subscribers(subscribers)
send_template_email(subscribers, "notifications/newanswer.html", {'answer': answer})
create_subscription_if_not_exists(question, answer.author)
def send_validation_email(request):
if not request.user.is_authenticated():
return HttpResponseUnauthorized(request)
else:
# We check if there are some old validation hashes. If there are -- we delete them.
try:
hash = ValidationHash.objects.get(user=request.user, type='email')
hash.delete()
except:
pass
# We don't care if there are previous cashes in the database... In every case we have to create a new one
hash = ValidationHash.objects.create_new(request.user, 'email', [request.user.email])
send_template_email([request.user], "auth/mail_validation.html", {'validation_code': hash})
request.user.message_set.create(message=_("A message with an email validation link was just sent to your address."))
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def send_validation_email(request):
if not request.user.is_authenticated():
return HttpResponseUnauthorized(request)
else:
try:
hash = ValidationHash.objects.get(user=request.user, type='email')
hash.delete()
# If we were able to get a previous validation hash we should raise an
# Exception immediately. Otherwise new validation hash will not be created
# and users will not receive the desired e-mail vaidation link.
raise Exception("Validation has already been sent")
except:
hash = ValidationHash.objects.create_new(request.user, 'email', [request.user.email])
send_template_email([request.user], "auth/mail_validation.html", {'validation_code': hash})
request.user.message_set.create(message=_("A message with an email validation link was just sent to your address."))
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def post(self, request, *args, **kwargs):
form = self.form_class(request.POST)
if form.is_valid():
# Process the data in form.cleaned_data
entry = QuestionList()
entry.first_name = form.data['first_name']
entry.last_name = form.data['last_name']
entry.waitinglistemail = form.data['waitinglistemail']
entry.sex = form.data['sex']
entry.industry_preference = form.data['industry_preference']
entry.funding_knowledge = form.data['funding_knowledge']
entry.site_rec = form.data['site_rec']
entry.income = form.data['income']
entry.funding_preference = form.data['funding_preference']
entry.created = datetime.datetime.now()
#s = form.data['dob']
#Convert date from 05/29/1986 to 1986--05--29
#entry.dob = s[-4:] + '-' + s[:2] + '-' + s[3:5]
entry.dob = form.cleaned_data['dob']
entry.save()
messages.add_message(self.request,
self.messages["survey_added"]["level"],
self.messages["survey_added"]["text"])
# fake user object just to pass the data to the template
user = ForumUser(username='******' %
(entry.first_name, entry.last_name),
email=entry.waitinglistemail)
send_template_email([user],
"notifications/alphasignupcomplete.html",
{"survey": entry})
return redirect('confirm_questions') # Redirect after POST
else:
messages.add_message(self.request,
self.messages["input_error"]["level"],
self.messages["input_error"]["text"])
return render(request, self.template_name, {'form': form})
def handle(self, *args, **options):
if len(args) == 0 :
logging.error("require email arg!")
return
recipients = []
for email in args:
recipient = Recipient(email)
recipients.append(recipient)
logging.log(2,"send invitation email to %s" % email)
return send_template_email(recipients,"notifications/invitation.html",locals())
def send_validation_email(request):
if not request.user.is_authenticated():
return HttpResponseUnauthorized(request)
else:
# We check if there are some old validation hashes. If there are -- we delete them.
try:
hash = ValidationHash.objects.get(user=request.user, type='email')
hash.delete()
except:
pass
# We don't care if there are previous cashes in the database... In every case we have to create a new one
hash = ValidationHash.objects.create_new(request.user, 'email', [request.user.email])
additional_get_params = urllib.urlencode(dict([k, v.encode('utf-8')] for k, v in request.GET.items()))
send_template_email([request.user], "auth/mail_validation.html", {
'validation_code': hash,
'additional_get_params' : additional_get_params
})
messages.info(request, _("A message with an email validation link was just sent to your address."))
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def send_validation_email(request):
if not request.user.is_authenticated():
return HttpResponseUnauthorized(request)
else:
try:
hash = ValidationHash.objects.get(user=request.user, type='email')
hash.delete()
# If we were able to get a previous validation hash we should raise an
# Exception immediately. Otherwise new validation hash will not be created
# and users will not receive the desired e-mail vaidation link.
raise Exception("Validation has already been sent")
except:
hash = ValidationHash.objects.create_new(request.user, 'email',
[request.user.email])
send_template_email([request.user], "auth/mail_validation.html",
{'validation_code': hash})
request.user.message_set.create(message=_(
"A message with an email validation link was just sent to your address."
))
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def question_posted(action, new):
question = action.node
if not question.is_notifiable:
return
'''
## Mailing List Depending Upon Category
_recipient_ids = ",".join([category.mail_recipients for category in OsqaCategory.objects.filter(id__in = question.category.split(','))]).split(",")
recipient_ids =[ recipient.strip() for recipient in _recipient_ids if recipient.strip() ]
if len(recipient_ids):
category_subscribers = User.objects.filter(id__in =recipient_ids ).distinct()
all_subscribers = category_subscribers
## Mailing List Subscribers
recipient_list = [ recipient.strip() for recipient in question.recipientnames.split(',') if recipient.strip() ]
if len(recipient_list):
mailing_subscribers = User.objects.filter(id__in = recipient_list ).distinct()
if len(recipient_ids):
all_subscribers = category_subscribers | mailing_subscribers
else:
all_subscribers = mailing_subscribers
'''
send_template_email(all_subscribers, "notifications/newquestion.html", {'question': question})
subscription = QuestionSubscription(question=question, user=question.author)
subscription.save()
new_subscribers = User.objects.filter(
Q(subscription_settings__all_questions=True) |
Q(subscription_settings__all_questions_watched_tags=True,
marked_tags__name__in=question.tagnames.split(' '),
tag_selections__reason='good'))
for user in new_subscribers:
create_subscription_if_not_exists(question, user)
def feedback(request):
if request.method == "POST":
form = FeedbackForm(request.user, data=request.POST)
if form.is_valid():
context = {
"user": request.user,
"email": request.user.is_authenticated() and request.user.email or form.cleaned_data.get("email", None),
"message": form.cleaned_data["message"],
"name": request.user.is_authenticated()
and request.user.username
or form.cleaned_data.get("name", None),
"ip": request.META["REMOTE_ADDR"],
}
recipients = User.objects.filter(is_superuser=True)
send_template_email(recipients, "notifications/feedback.html", context)
msg = _("Thanks for the feedback!")
messages.info(request, msg)
return HttpResponseRedirect(get_next_url(request))
else:
form = FeedbackForm(request.user, initial={"next": get_next_url(request)})
return render_to_response("feedback.html", {"form": form}, context_instance=RequestContext(request))
def handle_noargs(self, **options):
try:
translation.activate(settings.LANGUAGE_CODE)
except:
logging.error("Unable to set the locale in the send emails cron job")
digest_control = EMAIL_DIGEST_FLAG.value
if digest_control is None:
digest_control = {
'LAST_DAILY': datetime.datetime.now() - datetime.timedelta(days=1),
'LAST_WEEKLY': datetime.datetime.now() - datetime.timedelta(days=1),
}
from_date = digest_control['LAST_DAILY']
digest_control['LAST_DAILY'] = datetime.datetime.now()
EMAIL_DIGEST_FLAG.set_value(digest_control)
users = User.objects.filter(subscription_settings__enable_notifications=True, subscription_settings__send_digest=True)
new_members = User.objects.filter(is_active=True, date_joined__gt=from_date).annotate(n_actions=models.Count('actions')).order_by('-n_actions')
new_member_count = new_members.count()
if new_member_count >= SHOW_N_MORE_ACTIVE_NEW_MEMBERS:
new_members = new_members[:SHOW_N_MORE_ACTIVE_NEW_MEMBERS]
show_all_users = True
else:
show_all_users = False
digest = DigestQuestionsIndex(from_date)
if (not new_member_count) and (not digest.count):
return
send_template_email(users, "notifications/digest.html", locals())
def handle(self, *args, **options):
#Users = User.objects.filter(password='******')
Users = User.objects.all()[0:1]
#logging.log(2,"send invitation email to %s" % email)
send_template_email(Users,"notifications/domain_change_notify.html",locals())
def process_action(self):
if not settings.SEND_WELCOME_EMAILS:
return
hash = ValidationHash.objects.create_new(self.user, 'email', [self.user.email])
send_template_email([self.user], "auth/welcome_email.html", {'validation_code': hash})
def test_email_settings(request):
user = request.user
send_template_email([user], "podporaadmin/mail_test.html", {"user": user})
return render_to_response("podporaadmin/test_email_settings.html", {"user": user}, RequestContext(request))
def process_action(self):
hash = ValidationHash.objects.create_new(self.user, 'email',
[self.user.email])
send_template_email([self.user], "auth/welcome_email.html",
{'validation_code': hash})
def process_action(self):
if not settings.SEND_WELCOME_EMAILS:
return
hash = ValidationHash.objects.create_new(self.user, 'email', [self.user.email])
send_template_email([self.user], "auth/welcome_email.html", {'validation_code': hash})
def process_action(self):
hash = ValidationHash.objects.create_new(self.user, 'email', [self.user.email])
send_template_email([self.user], "auth/welcome_email.html", {'validation_code': hash})
def revision_posted(action, new):
post = action.node
if post.node_type =="question":
question = post
else:
question = post.abs_parent
revisions = list(post.revisions.order_by('revised_at'))
rev_ctx = []
for i, revision in enumerate(revisions):
rev_ctx.append(dict(inst=revision, html=template.loader.get_template('node/revision.html').render(template.Context({
'title': revision.title,
'html': revision.html,
'category':revision.category_name(),
'tags': revision.tagname_list(),
# 'recipients':revision.recipientname_list(),
}))))
if i > 0:
rev_ctx[i]['diff'] = mark_safe(htmldiff(rev_ctx[i-1]['html'], rev_ctx[i]['html']))
else:
rev_ctx[i]['diff'] = mark_safe(rev_ctx[i]['html'])
if not (revision.summary):
rev_ctx[i]['summary'] = _('Revision n. %(rev_number)d') % {'rev_number': revision.revision}
else:
rev_ctx[i]['summary'] = revision.summary
rev_ctx.reverse()
#update mailing list according to last revision of category
if post.node_type =="question":
prev_question = revisions[-2]
present_question = revisions[-1]
if (prev_question.category != present_question.category):
## remove previous category subscriptions
_recipient_ids = ",".join([category.mail_recipients for category in OsqaCategory.objects.filter(id__in = prev_question.category.split(','))]).split(",")
recipient_ids =[ recipient.strip() for recipient in _recipient_ids if recipient.strip() ]
if len(recipient_ids):
category_subscribers = User.objects.filter(id__in =recipient_ids ).distinct()
for subscriber in category_subscribers:
remove_subscription_if_exists(question, subscriber)
## remove previous mailing subscriptions
if (prev_question.recipientnames != present_question.recipientnames):
recipient_list = [ recipient.strip() for recipient in prev_question.recipientnames.split(',') if recipient.strip() ]
if len(recipient_list):
mailing_subscribers = User.objects.filter(id__in = recipient_list ).distinct()
for subscriber in mailing_subscribers:
remove_subscription_if_exists(question, subscriber)
## Add present mailing subscriptions
if (prev_question.recipientnames != present_question.recipientnames):
recipient_list = [ recipient.strip() for recipient in present_question.recipientnames.split(',') if recipient.strip() ]
if len(recipient_list):
mailing_subscribers = User.objects.filter(id__in = recipient_list ).distinct()
for subscriber in mailing_subscribers:
create_subscription_if_not_exists(question, subscriber)
if (prev_question.category != present_question.category):
## Add present category subscriptions
_recipient_ids = ",".join([category.mail_recipients for category in OsqaCategory.objects.filter(id__in = present_question.category.split(','))]).split(",")
recipient_ids =[ recipient.strip() for recipient in _recipient_ids if recipient.strip() ]
if len(recipient_ids):
category_subscribers = User.objects.filter(id__in =recipient_ids ).distinct()
for subscriber in category_subscribers:
create_subscription_if_not_exists(question, subscriber)
if not post.is_notifiable or not question.is_notifiable:
return
subscribers = question.subscribers.all().distinct()
'''
addressbook_contacts = question.addressbook_contacts() ## query containing all users which are in address book
if addressbook_contacts.exists():
if subscribers.exists():
subscribers |= addressbook_contacts ## adding address book contacts
else:
subscribers = addressbook_contacts
'''
if subscribers.exists():
subscribers = filter_subscribers(subscribers.exclude(id=post.author.id))
try:
sender_mail = User.objects.get(user = post.author).mail;
sender = {'name':post.author.username,'email':sender_mail }
except: ## Use Default forum mail address in case of error
sender_mail = unicode(settings.DEFAULT_FROM_EMAIL)
sender = u'%s <%s>' % (unicode(settings.APP_SHORT_NAME), unicode(settings.DEFAULT_FROM_EMAIL))
if subscribers.exists():
send_template_email(subscribers, "notifications/emailrevision.html", {'post': post, 'revisions' : rev_ctx,'question':question},sender = sender, reply_to = sender_mail)
create_subscription_if_not_exists(question, post.author)
