def testGetHostName(self):
"""Tests that a correct host name is returned.
"""
test_data = RequestData()
test_site = site.Site(link_id='test', hostname='test_host')
test_data.site = test_site
try:
expected_host = os.environ['HTTP_HOST'] = 'some.testing.host.tld'
self.assertEqual(system.getHostname(), expected_host)
finally:
if self.default_host is None:
del os.environ['HTTP_HOST']
else:
os.environ['HTTP_HOST'] = self.default_host
#test a data object
expected_host = 'test_host'
self.assertEqual(system.getHostname(data=test_data), expected_host)
test_data.site.hostname = ''
try:
expected_host = os.environ['HTTP_HOST'] = 'some.testing.host.tld'
self.assertEqual(system.getHostname(data=test_data), expected_host)
finally:
if self.default_host is None:
del os.environ['HTTP_HOST']
else:
os.environ['HTTP_HOST'] = self.default_host
def sendNewOrganizationNotification(entity, module_name):
"""Sends out an invite notification to the applicant of the Organization.
Args:
entity : An accepted OrgAppRecord
"""
program_entity = entity.survey.scope
url = 'http://%(host)s%(redirect)s' % {
'redirect': redirects.getApplicantRedirect(entity,
{'url_name': '%s/org' % module_name,
'program': program_entity}),
'host': system.getHostname(),
}
message_properties = {
'org_name': entity.name,
'program_name': program_entity.name,
'url': url
}
subject = DEF_NEW_ORG_MSG_FMT % {
'group_name': entity.name,
}
template = DEF_NEW_ORG_TEMPLATE
for to in [entity.main_admin, entity.backup_admin]:
if not to:
continue
sendNotification(to, None, message_properties, subject, template)
def getFirstTaskConfirmationContext(student):
"""Sends notification to the GCI student, when he or she completes their
first task.
Args:
student: the student who should receive the confirmation
"""
user = student.parent()
to = accounts.denormalizeAccount(user.account).email()
subject = DEF_FIRST_TASK_CONFIRMATION_SUBJECT
program = student.scope
kwargs = {
'sponsor': program.scope_path,
'program': program.link_id
}
url = reverse('gci_student_form_upload', kwargs=kwargs)
protocol = 'http'
hostname = system.getHostname()
context = {
'student_forms_link': '%s://%s%s' % (protocol, hostname, url),
}
template = DEF_FIRST_TASK_CONFIRMATION_TEMPLATE
body = loader.render_to_string(template, context)
return mailer.getMailContext(to=to, subject=subject, html=body, bcc=[])
def sendNewReviewNotification(to_user, review, reviewed_name, redirect_url):
"""Sends out a notification to alert the user of a new Review.
Args:
to_user: The user who should receive a notification
review: The review which triggers this notification
reviewed_name: Name of the entity reviewed
redirect_url: URL to which the follower should be sent for more information
"""
review_notification_url = 'http://%(host)s%(redirect_url)s' % {
'host' : system.getHostname(),
'redirect_url': redirect_url}
message_properties = {'review_notification_url': review_notification_url,
'reviewer_name': review.author_name(),
'reviewed_name': reviewed_name,
'review_content': review.content,
'review_visibility': 'public' if review.is_public else 'private',
}
# determine the subject
review_type = 'public' if review.is_public else 'private'
subject = DEF_NEW_REVIEW_SUBJECT_FMT % (review_type, reviewed_name)
template = DEF_NEW_REVIEW_NOTIFICATION_TEMPLATE
# send the notification from the system
# TODO(srabbelier): do this in a task instead
sendNotification(to_user, None, message_properties, subject, template)
def sendInviteNotification(entity):
"""Sends out an invite notification to the user the request is for.
Args:
entity : A request containing the information needed to create the message
"""
from soc.logic.models.user import logic as user_logic
from soc.views.models.role import ROLE_VIEWS
invitation_url = 'http://%(host)s%(index)s' % {
'host' : system.getHostname(),
'index': redirects.getInviteProcessRedirect(entity, None),
}
role_params = ROLE_VIEWS[entity.role].getParams()
message_properties = {
'role_verbose' : role_params['name'],
'group': entity.group.name,
'invitation_url': invitation_url,
}
subject = DEF_INVITATION_MSG_FMT % {
'role_verbose' : role_params['name'],
'group' : entity.group.name
}
template = DEF_GROUP_INVITE_NOTIFICATION_TEMPLATE
from_user = user_logic.getCurrentUser()
sendNotification(entity.user, from_user, message_properties, subject, template)
def sendNewRequestNotification(request_entity):
"""Sends out a notification to the persons who can process this Request.
Args:
request_entity: an instance of Request model
"""
from soc.logic.helper import notifications
from soc.logic.models.role import ROLE_LOGICS
from soc.views.models.role import ROLE_VIEWS
# get the users who should get the notification
to_users = []
# retrieve the Role Logics which we should query on
role_logic = ROLE_LOGICS[request_entity.role]
role_logics_to_notify = role_logic.getRoleLogicsToNotifyUponNewRequest()
# the scope of the roles is the same as the scope of the Request entity
fields = {'scope': request_entity.group,
'status': 'active'}
for role_logic in role_logics_to_notify:
roles = role_logic.getForFields(fields)
for role_entity in roles:
# TODO: this might lead to double notifications
to_users.append(role_entity.user)
# get the user the request is from
user_entity = request_entity.user
role_params = ROLE_VIEWS[request_entity.role].getParams()
request_url = 'http://%(host)s%(redirect)s' % {
'host': system.getHostname(),
'redirect': redirects.getProcessRequestRedirect(request_entity, None),
}
message_properties = {
'requester': user_entity.name,
'role_verbose': role_params['name'],
'group': request_entity.group.name,
'request_url': request_url
}
subject = DEF_NEW_REQUEST_MSG_FMT % {
'requester': user_entity.name,
'role_verbose' : role_params['name'],
'group' : request_entity.group.name
}
template = DEF_NEW_REQUEST_NOTIFICATION_TEMPLATE
for to_user in to_users:
notifications.sendNotification(to_user, None, message_properties,
subject, template)
def key(entity): """Returns the memcache key for an entities homepage. """ host = system.getHostname() version = system.getAppVersion() kind = entity.kind() key = entity.key().id_or_name() return 'homepage_for_%s_%s_%s_%s' % (host, version, kind, key)
def isReferrerSelf(request,
expected_prefix=None, suffix=None, url_name=None):
"""Returns True if HTTP referrer path starts with the HTTP request path.
Args:
request: the Django HTTP request object; request.path is used if
expected_path is not supplied (the most common usage)
expected_prefix: optional HTTP path to use instead of the one in
request.path; default is None (use request.path)
suffix: suffix to remove from the HTTP request path before comparing
it to the HTTP referrer path in the HTTP request object headers
(this is often an link ID, for example, that may be changing from
a POST referrer to a GET redirect target)
url_name: url name of the entity that is being created
Returns:
True if HTTP referrer path begins with the HTTP request path (either
request.path or expected_prefix instead if it was supplied), after
any suffix was removed from that request path
False otherwise
"""
http_from = request.META.get('HTTP_REFERER')
if not http_from:
# no HTTP referrer, so cannot possibly start with expected prefix
return False
http_host = 'http://%s/%s' % (system.getHostname(), url_name)
if http_from.startswith(http_host):
return True
from_path = urlparse.urlparse(http_from).path
if not expected_prefix:
# use HTTP request path, since expected_prefix was not supplied
expected_prefix = request.path
if suffix:
# remove suffix (such as a link ID) before comparison
chars_to_remove = len(suffix)
if not suffix.startswith('/'):
chars_to_remove = chars_to_remove + 1
expected_prefix = expected_prefix[:-chars_to_remove]
if not from_path.startswith(expected_prefix):
# expected prefix did not match first part of HTTP referrer path
return False
# HTTP referrer started with (possibly truncated) expected prefix
return True
def isReferrerSelf(request, expected_prefix=None, suffix=None, url_name=None):
"""Returns True if HTTP referrer path starts with the HTTP request path.
Args:
request: the Django HTTP request object; request.path is used if
expected_path is not supplied (the most common usage)
expected_prefix: optional HTTP path to use instead of the one in
request.path; default is None (use request.path)
suffix: suffix to remove from the HTTP request path before comparing
it to the HTTP referrer path in the HTTP request object headers
(this is often an link ID, for example, that may be changing from
a POST referrer to a GET redirect target)
url_name: url name of the entity that is being created
Returns:
True if HTTP referrer path begins with the HTTP request path (either
request.path or expected_prefix instead if it was supplied), after
any suffix was removed from that request path
False otherwise
"""
http_from = request.META.get('HTTP_REFERER')
if not http_from:
# no HTTP referrer, so cannot possibly start with expected prefix
return False
http_host = 'http://%s/%s' % (system.getHostname(), url_name)
if http_from.startswith(http_host):
return True
from_path = urlparse.urlparse(http_from).path
if not expected_prefix:
# use HTTP request path, since expected_prefix was not supplied
expected_prefix = request.path
if suffix:
# remove suffix (such as a link ID) before comparison
chars_to_remove = len(suffix)
if not suffix.startswith('/'):
chars_to_remove = chars_to_remove + 1
expected_prefix = expected_prefix[:-chars_to_remove]
if not from_path.startswith(expected_prefix):
# expected prefix did not match first part of HTTP referrer path
return False
# HTTP referrer started with (possibly truncated) expected prefix
return True
def assignSlots(self, request, access_type, page_name=None,
params=None, **kwargs):
"""View that allows to assign slots to orgs.
"""
from soc.modules.gsoc.views.models.organization import view as org_view
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
description = self.DEF_SLOTS_ALLOCATION_MSG
org_params = org_view.getParams().copy()
org_params['list_description'] = description
org_params['list_template'] = "modules/gsoc/program/list/allocation.html"
org_params['public_field_props'] = {
"link_id": {
"hidden": True,
}
}
org_params['public_row_action'] = {}
org_params['public_row_extra'] = lambda entity: {}
org_params['public_conf_extra'] = {
"rowNum": -1,
"rowList": [],
}
org_params['public_field_keys'] = [
"name", "slots_desired", "nr_applications", "nr_mentors",
"locked", "slots_ass", "slots", "link_id",
]
org_params['public_field_names'] = [
"Name", "Desired", "#Proposals", "#Mentors",
"Locked?", "Slots Assigned", "Slots Visible to Org", "Link ID",
]
fields = {
'scope': program_entity,
'status': ['new', 'active', 'inactive']
}
return_url = "http://%(host)s%(index)s" % {
'host' : system.getHostname(),
'index': redirects.getSlotsRedirect(program_entity, params)
}
context = {
'total_slots': program_entity.slots,
'uses_json': True,
'uses_slot_allocator': True,
'return_url': return_url,
}
return self.list(request, 'allow', page_name=page_name, params=org_params,
filter=fields, context=context)
def sendNewNotificationMessage(notification_entity):
"""Sends an email to a user about a new notification.
Args:
notification_entity: Notification about which the message should be sent
"""
from soc.logic.models.site import logic as site_logic
from soc.views.models.notification import view as notification_view
# create the url to show this notification
notification_url = 'http://%(host)s%(index)s' % {
'host' : system.getHostname(),
'index': redirects.getPublicRedirect(notification_entity,
notification_view.getParams())}
sender = mail_dispatcher.getDefaultMailSender()
site_entity = site_logic.getSingleton()
site_name = site_entity.site_name
# get the default mail sender
default_sender = mail_dispatcher.getDefaultMailSender()
if not default_sender:
# no valid sender found, abort
logging.error('No default sender')
return
else:
(sender_name, sender) = default_sender
to = accounts.denormalizeAccount(notification_entity.scope.account).email()
subject = DEF_NEW_NOTIFICATION_MSG_SUBJECT_FMT % notification_entity.subject
# create the message contents
messageProperties = {
'to_name': notification_entity.scope.name,
'sender_name': sender_name,
'to': to,
'sender': sender,
'site_name': site_name,
'subject': force_unicode(subject),
'notification' : notification_entity,
'notification_url' : notification_url
}
# send out the message using the default new notification template
mail_dispatcher.sendMailFromTemplate('soc/mail/new_notification.html',
messageProperties)
def _fullUrl(self, url, full, secure):
"""Returns the full version of the url iff full.
The full version starts with http:// and includes getHostname().
"""
if (not full) and (system.isLocal() or not secure):
return url
if secure:
protocol = 'https'
hostname = system.getSecureHostname()
else:
protocol = 'http'
hostname = system.getHostname(self._data)
return '%s://%s%s' % (protocol, hostname, url)
def _review(self, request, params, app_entity, status, **kwargs):
"""Sends out an email if an org_app has been accepted or rejected.
For params see group_app.View._review().
"""
if status == 'accepted' or status == 'rejected':
default_sender = mail_dispatcher.getDefaultMailSender()
if not default_sender:
# no default sender abort
return
else:
(sender_name, sender) = default_sender
# construct the contents of the email
admin_entity = app_entity.applicant
backup_entity = app_entity.backup_admin
context = {
'sender': sender,
'sender_name': sender_name,
'program_name': app_entity.scope.name,
'org_app_name': app_entity.name
}
if status == 'accepted':
# use the accepted template and subject
template = params['accepted_mail_template']
context['subject'] = 'Congratulations!'
context['HTTP_host'] = 'http://%s' % (system.getHostname())
elif status == 'rejected':
# use the rejected template and subject
template = params['rejected_mail_template']
context['subject'] = 'Thank you for your application'
for to in [admin_entity, backup_entity]:
if not to:
continue
email = accounts.denormalizeAccount(to.account).email()
context['to'] = email
context['to_name'] = to.name
# send out the constructed email
mail_dispatcher.sendMailFromTemplate(template, context)
def sendWelcomeMessage(user_entity):
"""Sends out a welcome message to a user.
Args:
user_entity: User entity which the message should be send to
"""
from soc.logic.models.site import logic as site_logic
# get site name
site_entity = site_logic.getSingleton()
site_name = site_entity.site_name
# get the default mail sender
default_sender = mail_dispatcher.getDefaultMailSender()
if not default_sender:
# no valid sender found, should not happen but abort anyway
logging.error('No default sender')
return
else:
sender_name, sender = default_sender
to = accounts.denormalizeAccount(user_entity.account).email()
# create the message contents
messageProperties = {
'to_name': user_entity.name,
'sender_name': sender_name,
'to': to,
'sender': sender,
'subject': DEF_WELCOME_MSG_FMT % {
'site_name': site_name,
'name': user_entity.name
},
'site_name': site_name,
'site_location': 'http://%s' % system.getHostname(),
}
# send out the message using the default welcome template
mail_dispatcher.sendMailFromTemplate('soc/mail/welcome.html',
messageProperties)
def assignSlots(self,
request,
access_type,
page_name=None,
params=None,
**kwargs):
"""View that allows to assign slots to orgs.
"""
from soc.modules.gsoc.views.models.organization import view as org_view
org_params = org_view.getParams().copy()
org_params['list_template'] = 'soc/program/allocation/allocation.html'
org_params['list_heading'] = 'soc/program/allocation/heading.html'
org_params['list_row'] = 'soc/program/allocation/row.html'
org_params['list_pagination'] = 'soc/list/no_pagination.html'
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
description = self.DEF_SLOTS_ALLOCATION_MSG
content = self._getOrgsWithProfilesList(program_entity, org_view,
description, False)
contents = [content]
return_url = "http://%(host)s%(index)s" % {
'host': system.getHostname(),
'index': redirects.getSlotsRedirect(program_entity, params)
}
context = {
'total_slots': program_entity.slots,
'uses_json': True,
'uses_slot_allocator': True,
'return_url': return_url,
}
return self._list(request, org_params, contents, page_name, context)
def getTaskCommentContext(task, comment, to_emails):
"""Sends out notifications to the subscribers.
Args:
task: task entity that comment made on.
comment: comment entity.
to_emails: list of recepients for the notification.
"""
url_kwargs = {
'sponsor': task.program.scope_path,
'program': task.program.link_id,
'id': task.key().id(),
}
task_url = 'http://%(host)s%(task)s' % {
'host': system.getHostname(),
'task': reverse('gci_view_task', kwargs=url_kwargs)}
commented_by = comment.created_by.name if comment.created_by else "Melange"
message_properties = {
'commented_by': commented_by,
'comment_title': comment.title,
'comment_content': comment.content,
'group': task.org.name,
'program_name': task.program.name,
'sender_name': 'The %s Team' % site.singleton().site_name,
'task_title': task.title,
'task_url': task_url,
}
subject = DEF_NEW_TASK_COMMENT_SUBJECT % message_properties
template = DEF_NEW_TASK_COMMENT_NOTIFICATION_TEMPLATE
body = loader.render_to_string(template, dictionary=message_properties)
return mailer.getMailContext(to=[], subject=subject, html=body, bcc=to_emails)
def sendSurveyReminderForProject(request, *args, **kwargs):
"""Sends a reminder mail for a given StudentProject and Survey.
A reminder is only send if no record is on file for the given Survey and
StudentProject.
Expects the following to be present in the POST dict:
survey_key: specifies the key name for the ProjectSurvey to send reminders
for
survey_type: either project or grading depending on the type of Survey
project_key: key which specifies the project to send a reminder for
Args:
request: Django Request object
"""
from soc.logic import mail_dispatcher
from soc.logic.models.site import logic as site_logic
from soc.views.helper import redirects
from soc.modules.gsoc.logic.models.org_admin import logic as org_admin_logic
from soc.modules.gsoc.logic.models.student_project import logic as \
student_project_logic
from soc.modules.gsoc.logic.models.survey import grading_logic
from soc.modules.gsoc.logic.models.survey import project_logic
post_dict = request.POST
project_key = post_dict.get('project_key')
survey_key = post_dict.get('survey_key')
survey_type = post_dict.get('survey_type')
if not (project_key and survey_key and survey_type):
# invalid task data, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid sendSurveyReminderForProject data: %s' % post_dict)
# set logic depending on survey type specified in POST
if survey_type == 'project':
survey_logic = project_logic
elif survey_type == 'grading':
survey_logic = grading_logic
# retrieve the project and survey
student_project = student_project_logic.getFromKeyName(project_key)
if not student_project:
# no existing project found, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid project specified %s:' % project_key)
survey = survey_logic.getFromKeyName(survey_key)
if not survey:
# no existing survey found, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid survey specified %s:' % survey_key)
# try to retrieve an existing record
record_logic = survey_logic.getRecordLogic()
fields = {'project': student_project,
'survey': survey}
record_entity = record_logic.getForFields(fields, unique=True)
if not record_entity:
# send reminder email because we found no record
student_entity = student_project.student
site_entity = site_logic.getSingleton()
if survey_type == 'project':
survey_redirect = redirects.getTakeSurveyRedirect(
survey,{'url_name': 'gsoc/project_survey'})
to_role = student_entity
mail_template = 'soc/project_survey/mail/reminder_gsoc.html'
elif survey_type == 'grading':
survey_redirect = redirects.getTakeSurveyRedirect(
survey,{'url_name': 'gsoc/grading_project_survey'})
to_role = student_project.mentor
mail_template = 'soc/grading_project_survey/mail/reminder_gsoc.html'
survey_url = "http://%(host)s%(redirect)s" % {
'redirect': survey_redirect,
'host': system.getHostname(),
}
# set the context for the mail template
mail_context = {
'student_name': student_entity.name(),
'project_title': student_project.title,
'survey_url': survey_url,
'survey_end': survey.survey_end,
'to_name': to_role.name(),
'site_name': site_entity.site_name,
}
# set the sender
(_, sender_address) = mail_dispatcher.getDefaultMailSender()
mail_context['sender'] = sender_address
# set the receiver and subject
mail_context['to'] = to_role.email
mail_context['subject'] = 'Evaluation Survey "%s" Reminder' %(survey.title)
# find all org admins for the project's organization
org_entity = student_project.scope
fields = {'scope': org_entity,
'status': 'active'}
org_admin_entities = org_admin_logic.getForFields(fields)
# collect email addresses for all found org admins
org_admin_addresses = []
for org_admin_entity in org_admin_entities:
org_admin_addresses.append(org_admin_entity.email)
if org_admin_addresses:
mail_context['cc'] = org_admin_addresses
# send out the email
mail_dispatcher.sendMailFromTemplate(mail_template, mail_context)
# return OK
return http.HttpResponse()
def assignSlots(self,
request,
access_type,
page_name=None,
params=None,
**kwargs):
"""View that allows to assign slots to orgs.
"""
from soc.modules.gsoc.views.models.organization import view as org_view
program_entity = program_logic.getFromKeyFieldsOr404(kwargs)
description = self.DEF_SLOTS_ALLOCATION_MSG
org_params = org_view.getParams().copy()
org_params['list_description'] = description
org_params[
'list_template'] = "modules/gsoc/program/list/allocation.html"
org_params['public_field_props'] = {
"link_id": {
"hidden": True,
}
}
org_params['public_row_action'] = {}
org_params['public_row_extra'] = lambda entity: {}
org_params['public_conf_extra'] = {
"rowNum": -1,
"rowList": [],
}
org_params['public_field_keys'] = [
"name",
"slots_desired",
"nr_applications",
"nr_mentors",
"locked",
"slots_ass",
"slots",
"link_id",
]
org_params['public_field_names'] = [
"Name",
"Desired",
"#Proposals",
"#Mentors",
"Locked?",
"Slots Assigned",
"Slots Visible to Org",
"Link ID",
]
fields = {
'scope': program_entity,
'status': ['new', 'active', 'inactive']
}
return_url = "http://%(host)s%(index)s" % {
'host': system.getHostname(),
'index': redirects.getSlotsRedirect(program_entity, params)
}
context = {
'total_slots': program_entity.slots,
'uses_json': True,
'uses_slot_allocator': True,
'return_url': return_url,
}
return self.list(request,
'allow',
page_name=page_name,
params=org_params,
filter=fields,
context=context)
def sendSurveyReminderForProject(self, request, *args, **kwargs):
"""Sends a reminder mail for a given StudentProject and Survey.
A reminder is only send if no record is on file for the given Survey and
StudentProject.
Expects the following to be present in the POST dict:
survey_key: specifies the key name for the ProjectSurvey to send reminders
for
survey_type: either project or grading depending on the type of Survey
project_key: encoded Key which specifies the project to send a reminder
for
Args:
request: Django Request object
"""
post_dict = request.POST
project_key = post_dict.get('project_key')
survey_key = post_dict.get('survey_key')
survey_type = post_dict.get('survey_type')
if not (project_key and survey_key and survey_type):
# invalid task data, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid sendSurveyReminderForProject data: %s' % post_dict)
# set model depending on survey type specified in POST
if survey_type == 'project':
survey_model = ProjectSurvey
record_model = GSoCProjectSurveyRecord
elif survey_type == 'grading':
survey_model = GradingProjectSurvey
record_model = GSoCGradingProjectSurveyRecord
else:
return error_handler.logErrorAndReturnOK(
'%s is an invalid survey_type' %survey_type)
# retrieve the project and survey
project_key = db.Key(project_key)
project = GSoCProject.get(project_key)
if not project:
# no existing project found, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid project specified %s:' % project_key)
survey = survey_model.get_by_key_name(survey_key)
if not survey:
# no existing survey found, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid survey specified %s:' % survey_key)
# try to retrieve an existing record
q = record_model.all()
q.filter('project', project)
q.filter('survey', survey)
record = q.get()
if not record:
# send reminder email because we found no record
student_profile = project.parent()
site_entity = site.singleton()
if survey_type == 'project':
url_name = 'gsoc_take_student_evaluation'
to_name = student_profile.name()
to_address = student_profile.email
mail_template = 'v2/modules/gsoc/reminder/student_eval_reminder.html'
elif survey_type == 'grading':
url_name = 'gsoc_take_mentor_evaluation'
mentors = db.get(project.mentors)
to_address = [m.email for m in mentors]
to_name = 'mentor(s) for project "%s"' %(project.title)
mail_template = \
'v2/modules/gsoc/reminder/mentor_eval_reminder.html'
program = project.program
hostname = system.getHostname()
url_kwargs = {
'sponsor': program.scope.link_id,
'program': program.link_id,
'survey': survey.link_id,
'user': student_profile.link_id,
'id': str(project.key().id()),
}
url = reverse(url_name, kwargs=url_kwargs)
survey_url = '%s://%s%s' % ('http', hostname, url)
# set the context for the mail template
mail_context = {
'student_name': student_profile.name(),
'project_title': project.title,
'survey_url': survey_url,
'survey_end': survey.survey_end,
'to_name': to_name,
'site_name': site_entity.site_name,
'sender_name': "The %s Team" % site_entity.site_name,
}
# set the sender
(_, sender_address) = mail_dispatcher.getDefaultMailSender()
mail_context['sender'] = sender_address
# set the receiver and subject
mail_context['to'] = to_address
mail_context['subject'] = \
'Evaluation Survey "%s" Reminder' %(survey.title)
# find all org admins for the project's organization
org = project.org
q = GSoCProfile.all()
q.filter('status', 'active')
q.filter('org_admin_for', org)
org_admins = q.fetch(1000)
# collect email addresses for all found org admins
org_admin_addresses = []
for org_admin in org_admins:
org_admin_addresses.append(org_admin.email)
if org_admin_addresses:
mail_context['cc'] = org_admin_addresses
# send out the email
mail_dispatcher.sendMailFromTemplate(mail_template, mail_context)
# return OK
return http.HttpResponse()
def sendSurveyReminderForProject(request, *args, **kwargs):
"""Sends a reminder mail for a given StudentProject and Survey.
A reminder is only send if no record is on file for the given Survey and
StudentProject.
Expects the following to be present in the POST dict:
survey_key: specifies the key name for the ProjectSurvey to send reminders
for
survey_type: either project or grading depending on the type of Survey
project_key: key which specifies the project to send a reminder for
Args:
request: Django Request object
"""
from soc.logic import mail_dispatcher
from soc.logic.models.site import logic as site_logic
from soc.views.helper import redirects
from soc.modules.gsoc.logic.models.org_admin import logic as org_admin_logic
from soc.modules.gsoc.logic.models.student_project import logic as \
student_project_logic
from soc.modules.gsoc.logic.models.survey import grading_logic
from soc.modules.gsoc.logic.models.survey import project_logic
post_dict = request.POST
project_key = post_dict.get('project_key')
survey_key = post_dict.get('survey_key')
survey_type = post_dict.get('survey_type')
if not (project_key and survey_key and survey_type):
# invalid task data, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid sendSurveyReminderForProject data: %s' % post_dict)
# set logic depending on survey type specified in POST
if survey_type == 'project':
survey_logic = project_logic
elif survey_type == 'grading':
survey_logic = grading_logic
# retrieve the project and survey
student_project = student_project_logic.getFromKeyName(project_key)
if not student_project:
# no existing project found, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid project specified %s:' % project_key)
survey = survey_logic.getFromKeyName(survey_key)
if not survey:
# no existing survey found, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid survey specified %s:' % survey_key)
# try to retrieve an existing record
record_logic = survey_logic.getRecordLogic()
fields = {'project': student_project, 'survey': survey}
record_entity = record_logic.getForFields(fields, unique=True)
if not record_entity:
# send reminder email because we found no record
student_entity = student_project.student
site_entity = site_logic.getSingleton()
if survey_type == 'project':
survey_redirect = redirects.getTakeSurveyRedirect(
survey, {'url_name': 'gsoc/project_survey'})
to_role = student_entity
mail_template = 'soc/project_survey/mail/reminder_gsoc.html'
elif survey_type == 'grading':
survey_redirect = redirects.getTakeSurveyRedirect(
survey, {'url_name': 'gsoc/grading_project_survey'})
to_role = student_project.mentor
mail_template = 'soc/grading_project_survey/mail/reminder_gsoc.html'
survey_url = "http://%(host)s%(redirect)s" % {
'redirect': survey_redirect,
'host': system.getHostname(),
}
# set the context for the mail template
mail_context = {
'student_name': student_entity.name(),
'project_title': student_project.title,
'survey_url': survey_url,
'survey_end': survey.survey_end,
'to_name': to_role.name(),
'site_name': site_entity.site_name,
}
# set the sender
(_, sender_address) = mail_dispatcher.getDefaultMailSender()
mail_context['sender'] = sender_address
# set the receiver and subject
mail_context['to'] = to_role.email
mail_context['subject'] = 'Evaluation Survey "%s" Reminder' % (
survey.title)
# find all org admins for the project's organization
org_entity = student_project.scope
fields = {'scope': org_entity, 'status': 'active'}
org_admin_entities = org_admin_logic.getForFields(fields)
# collect email addresses for all found org admins
org_admin_addresses = []
for org_admin_entity in org_admin_entities:
org_admin_addresses.append(org_admin_entity.email)
if org_admin_addresses:
mail_context['cc'] = org_admin_addresses
# send out the email
mail_dispatcher.sendMailFromTemplate(mail_template, mail_context)
# return OK
return http.HttpResponse()
def sendCommentNotificationMail(self, request, *args, **kwargs):
"""Appengine task that sends mail to the subscribed users.
Expects the following to be present in the POST dict:
comment_key: Specifies the comment id for which to send the notifications
Args:
request: Django Request object
"""
# TODO(ljvderijk): If all mails are equal we can sent one big bcc mail
# set default batch size
batch_size = 10
post_dict = request.POST
comment_key = post_dict.get("comment_key")
if not comment_key:
# invalid task data, log and return OK
return error_handler.logErrorAndReturnOK("Invalid createNotificationMail data: %s" % post_dict)
comment_key = db.Key(comment_key)
comment = GCIComment.get(comment_key)
if not comment:
# invalid comment specified, log and return OK
return error_handler.logErrorAndReturnOK("Invalid comment specified: %s" % (comment_key))
task = comment.parent()
subscription = GCITaskSubscription.all().ancestor(task).fetch(1)
# check and retrieve the subscriber_start_key that has been done last
idx = int(post_dict.get("subscriber_start_index", 0))
subscribers = db.get(subscription.subscribers[idx : idx + batch_size])
url_kwargs = {
"sponsor": task.program.scope_path,
"program": task.program.link_id,
"id": task.key().id_or_name(),
}
task_url = "http://%(host)s%(task)s" % {
"host": system.getHostname(),
"task": reverse("gci_view_task", kwargs=url_kwargs),
}
# create the data for the mail to be sent
message_properties = {
"task_url": task_url,
"redirect_url": "%(task_url)s#c%(cid)d" % {"task_url": task_url, "cid": comment.key().id_or_name()},
"comment_entity": comment,
"task_entity": task,
}
subject = self.DEF_TASK_UPDATE_SUBJECT % {"program_name": task.program.short_name, "title": task.title}
for subscriber in subscribers:
# TODO(ljvderijk): enable sending of mail after template fixes
# gci_notifications.sendTaskUpdateMail(subscriber, subject,
# message_properties)
pass
if len(subscribers) == batch_size:
# spawn task for sending out notifications to next set of subscribers
next_start = idx + batch_size
task_params = {"comment_key": str(comment_key), "subscriber_start_index": next_start}
task_url = "/tasks/gci/task/mail/comment"
new_task = taskqueue.Task(params=task_params, url=task_url)
new_task.add("mail")
# return OK
return http.HttpResponse()
def createNotificationMail(request, *args, **kwargs):
"""Appengine task that sends mail to the subscribed users.
Expects the following to be present in the POST dict:
comment_key: Specifies the comment id for which to send the notifications
task_key: Specifies the task key name for which the comment belongs to
Args:
request: Django Request object
"""
from soc.modules.gci.logic.helper import notifications as gci_notifications
from soc.modules.gci.logic.models import comment as gci_comment_logic
from soc.modules.gci.logic.models import task_subscription as \
gci_task_subscription_logic
# set default batch size
batch_size = 10
post_dict = request.POST
comment_key = post_dict.get('comment_key')
task_key = post_dict.get('task_key')
if not (comment_key and task_key):
# invalid task data, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid createNotificationMail data: %s' % post_dict)
comment_key = long(comment_key)
# get the task entity under which the specified comment was made
task_entity = gci_task_logic.logic.getFromKeyName(task_key)
# get the comment for the given id
comment_entity = gci_comment_logic.logic.getFromID(comment_key,
task_entity)
if not comment_entity:
# invalid comment specified, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid comment specified: %s/%s' % (comment_key, task_key))
# check and retrieve the subscriber_start_key that has been done last
idx = post_dict.get('subscriber_start_index', '')
subscriber_start_index = int(idx) if idx.isdigit() else 0
# get all subscribers to GCI task
fields = {
'task': task_entity,
}
ts_entity = gci_task_subscription_logic.logic.getForFields(fields,
unique=True)
subscribers = db.get(
ts_entity.subscribers[subscriber_start_index:subscriber_start_index +
batch_size])
task_url = "http://%(host)s%(task)s" % {
'host': system.getHostname(),
'task': redirects.getPublicRedirect(task_entity,
{'url_name': 'gci/task'}),
}
# create the data for the mail to be sent
message_properties = {
'task_url': task_url,
'redirect_url': "%(task_url)s#c%(cid)d" % {
'task_url': task_url,
'cid': comment_entity.key().id_or_name()
},
'comment_entity': comment_entity,
'task_entity': task_entity,
}
subject = DEF_TASK_UPDATE_SUBJECT_FMT % {
'program_name': task_entity.program.short_name,
'title': task_entity.title,
}
for subscriber in subscribers:
gci_notifications.sendTaskUpdateMail(subscriber, subject,
message_properties)
if len(subscribers) == batch_size:
# spawn task for sending out notifications to next set of subscribers
next_start = subscriber_start_index + batch_size
task_params = {
'comment_key': comment_key,
'task_key': task_key,
'subscriber_start_index': next_start
}
task_url = '/tasks/gci/task/mail/create'
new_task = taskqueue.Task(params=task_params, url=task_url)
new_task.add('mail')
# return OK
return http.HttpResponse()
def createNotificationMail(request, *args, **kwargs):
"""Appengine task that sends mail to the subscribed users.
Expects the following to be present in the POST dict:
comment_key: Specifies the comment id for which to send the notifications
task_key: Specifies the task key name for which the comment belongs to
Args:
request: Django Request object
"""
from soc.modules.gci.logic.helper import notifications as gci_notifications
from soc.modules.gci.logic.models import comment as gci_comment_logic
from soc.modules.gci.logic.models import task_subscription as \
gci_task_subscription_logic
# set default batch size
batch_size = 10
post_dict = request.POST
comment_key = post_dict.get('comment_key')
task_key = post_dict.get('task_key')
if not (comment_key and task_key):
# invalid task data, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid createNotificationMail data: %s' % post_dict)
comment_key = long(comment_key)
# get the task entity under which the specified comment was made
task_entity = gci_task_logic.logic.getFromKeyName(task_key)
# get the comment for the given id
comment_entity = gci_comment_logic.logic.getFromID(
comment_key, task_entity)
if not comment_entity:
# invalid comment specified, log and return OK
return error_handler.logErrorAndReturnOK(
'Invalid comment specified: %s/%s' % (comment_key, task_key))
# check and retrieve the subscriber_start_key that has been done last
idx = post_dict.get('subscriber_start_index', '')
subscriber_start_index = int(idx) if idx.isdigit() else 0
# get all subscribers to GCI task
fields = {
'task': task_entity,
}
ts_entity = gci_task_subscription_logic.logic.getForFields(
fields, unique=True)
subscribers = db.get(ts_entity.subscribers[
subscriber_start_index:subscriber_start_index+batch_size])
task_url = "http://%(host)s%(task)s" % {
'host': system.getHostname(),
'task': redirects.getPublicRedirect(
task_entity, {'url_name': 'gci/task'}),
}
# create the data for the mail to be sent
message_properties = {
'task_url': task_url,
'redirect_url': "%(task_url)s#c%(cid)d" % {
'task_url': task_url,
'cid': comment_entity.key().id_or_name()
},
'comment_entity': comment_entity,
'task_entity': task_entity,
}
subject = DEF_TASK_UPDATE_SUBJECT_FMT % {
'program_name': task_entity.program.short_name,
'title': task_entity.title,
}
for subscriber in subscribers:
gci_notifications.sendTaskUpdateMail(subscriber, subject,
message_properties)
if len(subscribers) == batch_size:
# spawn task for sending out notifications to next set of subscribers
next_start = subscriber_start_index + batch_size
task_params = {
'comment_key': comment_key,
'task_key': task_key,
'subscriber_start_index': next_start
}
task_url = '/tasks/gci/task/mail/create'
new_task = taskqueue.Task(params=task_params, url=task_url)
new_task.add('mail')
# return OK
return http.HttpResponse()
