def put(self):
"""Handles REST PUT verb with JSON payload."""
request = json.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(
request, 'announcement-put', {'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(
self, 401, 'Access denied.', {'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'Object not found.', {'key': key})
return
payload = request.get('payload')
transforms.dict_to_entity(entity, transforms.json_to_dict(
json.loads(payload), SCHEMA_DICT))
entity.put()
transforms.send_json_response(self, 200, 'Saved.')
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = json.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(request, 'announcement-put',
{'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(self, 401, 'Access denied.',
{'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(self, 404, 'Object not found.',
{'key': key})
return
payload = request.get('payload')
transforms.dict_to_entity(
entity, transforms.json_to_dict(json.loads(payload), SCHEMA_DICT))
entity.put()
transforms.send_json_response(self, 200, 'Saved.')
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(request, 'announcement-put',
{'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(self, 401, 'Access denied.',
{'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(self, 404, 'Object not found.',
{'key': key})
return
payload = request.get('payload')
transforms.dict_to_entity(
entity,
transforms.json_to_dict(transforms.loads(payload),
AnnouncementsItemRESTHandler.SCHEMA_DICT))
entity.put()
email_sent = False
if entity.send_email and not entity.is_draft:
# get all students email
all_students = self.get_students()
email_list = []
recipient = ""
for s in all_students:
if s.is_enrolled and s.email != "*****@*****.**":
recipient = s.name + "<" + s.email + ">"
email_list.append(recipient)
# send an announcement email
sender_address = "MOOC <*****@*****.**>"
user_address = email_list
subject = "MOOC Announcement: " + entity.title
body = ""
html = entity.html
mail.send_mail(sender_address,
"*****@*****.**",
subject,
body,
html=html,
bcc=user_address)
if entity.send_email:
message = 'Saved and sent.'
else:
message = 'Saved.'
transforms.send_json_response(self, 200, message)
def put_sample_announcements(self):
"""Loads sample data into a database."""
items = []
for item in samples.SAMPLE_ANNOUNCEMENTS:
entity = AnnouncementEntity()
transforms.dict_to_entity(entity, item)
entity.put()
items.append(entity)
return items
def put_sample_announcements(self):
"""Loads sample data into a database."""
items = []
for item in samples.SAMPLE_ANNOUNCEMENTS:
entity = AnnouncementEntity()
transforms.dict_to_entity(entity, item)
entity.put()
items.append(entity)
return items
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
edit_mode = request.get('mode')
if GLOBAL_DEBUG:
logging.warning('***RAM*** put request = ' + str(request))
if not self.assert_xsrf_token_or_fail(
request, 'teacher-put', {'key': key}):
return
if not TeacherRights.can_edit(self):
transforms.send_json_response(
self, 401, 'MobileCSP: Admin access denied.', {'key': key})
return
entity = TeacherEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'MobileCSP: Teacher Entity not found.', {'key': key})
return
schema = TeacherItemRESTHandler.SCHEMA()
payload = request.get('payload')
update_dict = transforms.json_to_dict(
transforms.loads(payload), schema.get_json_schema_dict())
# Get the teacher's user_id
user = Student.get_first_by_email(update_dict['email'])[0] # returns a tuple
if not user:
transforms.send_json_response(
self, 404, 'MobileCSP: No registered user found for ' + update_dict['email'], {'key': key})
return
# Check that the teacher isn't already registered
if update_dict['mode'] == 'Add':
teachers = TeacherEntity.get_teachers()
for teacher in teachers:
if teacher.email == update_dict['email']:
transforms.send_json_response(
self, 404, 'MobileCSP: User is already registered as a teacher ' + update_dict['email'], {'key': key})
return
if GLOBAL_DEBUG:
logging.debug('****RAM**** teacher id ' + str(user.user_id))
# Store the user_id
update_dict['user_id'] = user.user_id
transforms.dict_to_entity(entity, update_dict)
entity.put()
transforms.send_json_response(self, 200, 'Saved.')
def put_sample_wiki(self):
"""Loads sample data into a database."""
items = []
for item in samples.SAMPLE_WIKI_ENTRIES:
entity = WikiEntity()
transforms.dict_to_entity(entity, item)
entity.put()
items.append(entity)
return items
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(request, 'announcement-put',
{'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(self, 401, 'Access denied.',
{'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(self, 404, 'Object not found.',
{'key': key})
return
schema = AnnouncementsItemRESTHandler.SCHEMA(
'Announcement',
self.get_course().get_course_announcement_list_email())
payload = request.get('payload')
update_dict = transforms.json_to_dict(transforms.loads(payload),
schema.get_json_schema_dict())
entity.labels = utils.list_to_text(
LabelGroupsHelper.decode_labels_group(
update_dict.get('label_groups')))
transforms.dict_to_entity(entity, update_dict)
entity.put()
AnnouncementUtil.update_course_with_last_announcement(
self.app_context.get_namespace_name())
email_sent = False
if entity.send_email:
email_manager = notify.EmailManager(self.get_course())
email_sent = email_manager.send_announcement(
entity.title, entity.html, intent=ANNOUNCEMENTS_INTENT)
if entity.send_email and not email_sent:
if not self.get_course().get_course_announcement_list_email():
message = 'Saved. Announcement list not configured.'
else:
message = 'Saved, but there was an error sending email.'
else:
message = 'Saved.'
transforms.send_json_response(self, 200, message)
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(
request, 'announcement-put', {'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(
self, 401, 'Access denied.', {'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'Object not found.', {'key': key})
return
payload = request.get('payload')
transforms.dict_to_entity(entity, transforms.json_to_dict(
transforms.loads(payload),
AnnouncementsItemRESTHandler.SCHEMA_DICT))
entity.put()
email_sent = False
if entity.send_email and not entity.is_draft:
# get all students email
all_students = self.get_students()
email_list = []
recipient = ""
for s in all_students:
if s.is_enrolled and s.email != "*****@*****.**":
recipient = s.name + "<" + s.email + ">"
email_list.append(recipient)
# send an announcement email
sender_address = "MOOC <*****@*****.**>"
user_address = email_list
subject = "MOOC Announcement: " + entity.title
body = ""
html = entity.html
mail.send_mail(sender_address, "*****@*****.**", subject, body, html=html, bcc=user_address)
if entity.send_email:
message = 'Saved and sent.'
else:
message = 'Saved.'
transforms.send_json_response(self, 200, message)
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(
request, 'announcement-put', {'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(
self, 401, 'Access denied.', {'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'Object not found.', {'key': key})
return
schema = AnnouncementsItemRESTHandler.SCHEMA(
'Announcement',
self.get_course().get_course_announcement_list_email())
payload = request.get('payload')
update_dict = transforms.json_to_dict(
transforms.loads(payload), schema.get_json_schema_dict())
entity.labels = utils.list_to_text(
LabelGroupsHelper.decode_labels_group(
update_dict.get('label_groups')))
transforms.dict_to_entity(entity, update_dict)
entity.put()
email_sent = False
if entity.send_email:
email_manager = notify.EmailManager(self.get_course())
email_sent = email_manager.send_announcement(
entity.title, entity.html)
if entity.send_email and not email_sent:
if not self.get_course().get_course_announcement_list_email():
message = 'Saved. Announcement list not configured.'
else:
message = 'Saved, but there was an error sending email.'
else:
message = 'Saved.'
transforms.send_json_response(self, 200, message)
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(
request, 'announcement-put', {'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(
self, 401, 'Access denied.', {'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'Object not found.', {'key': key})
return
payload = request.get('payload')
transforms.dict_to_entity(entity, transforms.json_to_dict(
transforms.loads(payload),
AnnouncementsItemRESTHandler.SCHEMA_DICT))
entity.put()
email_sent = False
if entity.send_email:
email_manager = notify.EmailManager(self.get_course())
email_sent = email_manager.send_announcement(
entity.title, entity.html)
if entity.send_email and not email_sent:
if not self.get_course().get_course_announcement_list_email():
message = 'Saved. Announcement list not configured.'
else:
message = 'Saved, but there was an error sending email.'
else:
#if message is public
if entity.is_draft == False:
message = 'Saved and notifications sent correctly.'
send_push_notification(self.app_context.get_environ()['course']['title'], entity.title, entity.html)
else:
message = 'Saved.'
transforms.send_json_response(self, 200, message)
def test_bidirectional_transforms_succeed(self):
"""Tests that transforms entity<->dict<->json round trips correctly."""
referenced_model_key = ReferencedModel().put()
entity = UnvalidatedReference(
referenced_model_key=referenced_model_key)
entity.put()
transformed = transforms.entity_to_dict(entity)
self.assertEqual(referenced_model_key, entity.referenced_model_key)
self.assertEqual(referenced_model_key,
transformed['referenced_model_key'])
new_key = ReferencedModel().put()
transformed['referenced_model_key'] = new_key
restored = transforms.dict_to_entity(entity, transformed)
self.assertEqual(new_key, restored.referenced_model_key)
json = transforms.dict_to_json(transformed, None)
self.assertEqual(str(new_key), json['referenced_model_key'])
from_json = transforms.json_to_dict(
json, {'properties': {
'referenced_model_key': {
'type': 'string'
}
}})
self.assertEqual({'referenced_model_key': str(new_key)}, from_json)
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(
request, 'announcement-put', {'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(
self, 401, 'Access denied.', {'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'Object not found.', {'key': key})
return
payload = request.get('payload')
transforms.dict_to_entity(entity, transforms.json_to_dict(
transforms.loads(payload),
AnnouncementsItemRESTHandler.SCHEMA_DICT))
entity.put()
if not (entity.is_draft or entity.already_notified):
Notification.notify_all_students(url='/announcements',
text=entity.title)
entity.already_notified = True
entity.put()
email_sent = False
if entity.send_email:
email_manager = notify.EmailManager(self.get_course())
email_sent = email_manager.send_announcement(
entity.title, entity.html)
if entity.send_email and not email_sent:
if not self.get_course().get_course_announcement_list_email():
message = 'Saved. Announcement list not configured.'
else:
message = 'Saved, but there was an error sending email.'
else:
message = 'Saved.'
transforms.send_json_response(self, 200, message)
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(
request, self.ACTION, {'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(
self, 401, 'Access denied.', {'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'Object not found.', {'key': key})
return
schema = AnnouncementsItemRESTHandler.SCHEMA()
payload = request.get('payload')
update_dict = transforms.json_to_dict(
transforms.loads(payload), schema.get_json_schema_dict())
if entity.is_draft and not update_dict.get('set_draft'):
item = news.NewsItem(
str(TranslatableResourceAnnouncement.key_for_entity(entity)),
AnnouncementsStudentHandler.URL.lstrip('/'))
news.CourseNewsDao.add_news_item(item)
# The datetime widget returns a datetime object and we need a UTC date.
update_dict['date'] = update_dict['date'].date()
del update_dict['key'] # Don't overwrite key member method in entity.
transforms.dict_to_entity(entity, update_dict)
entity.put()
transforms.send_json_response(self, 200, 'Saved.')
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(
request, 'announcement-put', {'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(
self, 401, 'Access denied.', {'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'Object not found.', {'key': key})
return
schema = AnnouncementsItemRESTHandler.SCHEMA()
payload = request.get('payload')
update_dict = transforms.json_to_dict(
transforms.loads(payload), schema.get_json_schema_dict())
# The datetime widget returns a datetime object and we need a UTC date.
update_dict['date'] = update_dict['date'].date()
entity.labels = common_utils.list_to_text(
resources_display.LabelGroupsHelper.field_data_to_labels(
update_dict))
resources_display.LabelGroupsHelper.remove_label_field_data(update_dict)
transforms.dict_to_entity(entity, update_dict)
entity.put()
transforms.send_json_response(self, 200, 'Saved.')
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(
request, 'announcement-put', {'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(
self, 401, 'Access denied.', {'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'Object not found.', {'key': key})
return
schema = AnnouncementsItemRESTHandler.SCHEMA()
payload = request.get('payload')
update_dict = transforms.json_to_dict(
transforms.loads(payload), schema.get_json_schema_dict())
# The datetime widget returns a datetime object and we need a UTC date.
update_dict['date'] = datetime.datetime.strptime(
update_dict['date'], courses.ISO_8601_DATE_FORMAT).date()
entity.labels = utils.list_to_text(
LabelGroupsHelper.decode_labels_group(
update_dict.get('label_groups')))
transforms.dict_to_entity(entity, update_dict)
entity.put()
transforms.send_json_response(self, 200, 'Saved.')
def test_bidirectional_transforms_succeed(self):
"""Tests that transforms entity<->dict<->json round trips correctly."""
referenced_model_key = ReferencedModel().put()
entity = UnvalidatedReference(referenced_model_key=referenced_model_key)
entity.put()
transformed = transforms.entity_to_dict(entity)
self.assertEqual(referenced_model_key, entity.referenced_model_key)
self.assertEqual(referenced_model_key, transformed["referenced_model_key"])
new_key = ReferencedModel().put()
transformed["referenced_model_key"] = new_key
restored = transforms.dict_to_entity(entity, transformed)
self.assertEqual(new_key, restored.referenced_model_key)
json = transforms.dict_to_json(transformed, None)
self.assertEqual(str(new_key), json["referenced_model_key"])
from_json = transforms.json_to_dict(json, {"properties": {"referenced_model_key": {"type": "string"}}})
self.assertEqual({"referenced_model_key": str(new_key)}, from_json)
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(
request, 'announcement-put', {'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(
self, 401, 'Access denied.', {'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'Object not found.', {'key': key})
return
payload = request.get('payload')
transforms.dict_to_entity(entity, transforms.json_to_dict(
transforms.loads(payload),
AnnouncementsItemRESTHandler.SCHEMA_DICT))
entity.put()
# Google Course Builder starts:
#email_sent = False
#if entity.send_email:
# email_manager = notify.EmailManager(self.get_course())
# email_sent = email_manager.send_announcement(
# entity.title, entity.html)
#if entity.send_email and not email_sent:
# if not self.get_course().get_course_announcement_list_email():
# message = 'Saved. Announcement list not configured.'
# else:
# message = 'Saved, but there was an error sending email.'
#else:
# message = 'Saved.'
# Google Course Builder ends
# CGL-MOOC-Builder: Get user's Google App email and
# course title from course setting page
course = self.app_context.get_environ()['course']
if 'google_app_email' in course:
sender_email = course['google_app_email']
else:
sender_email = ''
if 'title' in course:
course_title = course['title']
else:
course_title = ''
# CGL-MOOC-Builder starts:
# Send an email when an announcement was made
if entity.send_email and not entity.is_draft:
# get all students email
all_students = self.get_students()
email_list = []
recipient = ""
for s in all_students:
if s.is_enrolled:
recipient = s.name + "<" + s.email + ">"
email_list.append(recipient)
# send an announcement email
sender_address = course_title + " <"+sender_email+">"
user_address = email_list
subject = "Announcement: " + entity.title
body = ""
html = entity.html
mail.send_mail(sender_address, "*****@*****.**", subject, body, html=html, bcc=user_address)
if entity.send_email:
message = 'Saved and sent.'
else:
message = 'Saved.'
# CGL-MOOC-Builder ends
transforms.send_json_response(self, 200, message)
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(
request, 'section-put', {'key': key}):
# logging.warning('***RAM*** put FAIL (saving) ' + str(request))
return
# logging.warning('***RAM*** put (saving) ' + str(request))
if not TeacherRights.can_edit_section(self):
transforms.send_json_response(
self, 401, 'MobileCSP: Access denied.', {'key': key})
return
entity = CourseSectionEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'MobileCSP: Course Section not found.', {'key': key})
return
schema = SectionItemRESTHandler.SCHEMA()
payload = request.get('payload')
update_dict = transforms.json_to_dict(
transforms.loads(payload), schema.get_json_schema_dict())
# Check for invalid emails -- email must be a registered student
# Found the regular expression on Stackoverflow
emails_raw = update_dict['students']
emails = re.findall(r'[\w\.-]+@[\w\.-]+', emails_raw)
return_code = 200
bad_emails = []
good_emails = []
for email in emails:
# email = email.strip(' \t\n\r')
if email:
logging.debug('***RAM*** email = |' + email + '|')
student = Student.get_first_by_email(email)[0] # returns a tuple
if not student:
bad_emails.append(email)
else:
good_emails.append(email)
confirm_message = 'Confirmation\n'
confirm_message += '------------\n\n'
if bad_emails:
logging.info('***RAM*** bad_emails found = ' + str(bad_emails))
return_code = 401
confirm_message = 'The following were invalid emails:\n'
for email in bad_emails:
confirm_message += email + '\n'
confirm_message += 'Either there is no student with that email\n'
confirm_message += 'registered for the course. Or there is a \n'
confirm_message += 'typo in the email address provided.\n\n'
if good_emails:
logging.info('***RAM*** good_emails found = ' + str(good_emails))
confirm_message += 'Students with the following emails\n'
confirm_message += 'are currently registered in your section:\n'
for email in good_emails:
confirm_message += email + '\n'
update_dict['students'] = ','.join(good_emails) # New-line delimited
transforms.dict_to_entity(entity, update_dict)
entity.put()
if return_code == 200:
confirm_message += 'Your section was successfully updated and saved.\n\n\n\n\n'
else:
confirm_message += 'Other information for your section was successfully updated and saved.\n\n\n\n\n'
confirm_message += 'Confirmation\n'
confirm_message += '------------\n'
transforms.send_json_response(
self, return_code, confirm_message, {'key': key})
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(request, 'section-put',
{'key': key}):
# logging.warning('***RAM*** put FAIL (saving) ' + str(request))
return
# logging.warning('***RAM*** put (saving) ' + str(request))
if not TeacherRights.can_edit_section(self):
transforms.send_json_response(self, 401,
'MobileCSP: Access denied.',
{'key': key})
return
entity = CourseSectionEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'MobileCSP: Course Section not found.',
{'key': key})
return
schema = SectionItemRESTHandler.SCHEMA()
payload = request.get('payload')
update_dict = transforms.json_to_dict(transforms.loads(payload),
schema.get_json_schema_dict())
# Check for invalid emails -- email must be a registered student
# Found the regular expression on Stackoverflow
emails_raw = update_dict['students']
emails = re.findall(r'[\w\.-]+@[\w\.-]+', emails_raw)
return_code = 200
bad_emails = []
good_emails = []
for email in emails:
# email = email.strip(' \t\n\r')
if email:
logging.debug('***RAM*** email = |' + email + '|')
student = Student.get_first_by_email(email)[
0] # returns a tuple
if not student:
bad_emails.append(email)
else:
good_emails.append(email)
confirm_message = 'Confirmation\n'
confirm_message += '------------\n\n'
if bad_emails:
logging.info('***RAM*** bad_emails found = ' + str(bad_emails))
return_code = 401
confirm_message = 'The following were invalid emails:\n'
for email in bad_emails:
confirm_message += email + '\n'
confirm_message += 'Either there is no student with that email\n'
confirm_message += 'registered for the course. Or there is a \n'
confirm_message += 'typo in the email address provided.\n\n'
if good_emails:
logging.info('***RAM*** good_emails found = ' + str(good_emails))
confirm_message += 'Students with the following emails\n'
confirm_message += 'are currently registered in your section:\n'
for email in good_emails:
confirm_message += email + '\n'
update_dict['students'] = ','.join(
good_emails) # New-line delimited
transforms.dict_to_entity(entity, update_dict)
entity.put()
if return_code == 200:
confirm_message += 'Your section was successfully updated and saved.\n\n\n\n\n'
else:
confirm_message += 'Other information for your section was successfully updated and saved.\n\n\n\n\n'
confirm_message += 'Confirmation\n'
confirm_message += '------------\n'
transforms.send_json_response(self, return_code, confirm_message,
{'key': key})
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
edit_mode = request.get('mode')
if GLOBAL_DEBUG:
logging.warning('***RAM*** put request = ' + str(request))
if not self.assert_xsrf_token_or_fail(request, 'teacher-put',
{'key': key}):
return
if not TeacherRights.can_edit(self):
transforms.send_json_response(self, 401,
'MobileCSP: Admin access denied.',
{'key': key})
return
entity = TeacherEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'MobileCSP: Teacher Entity not found.',
{'key': key})
return
schema = TeacherItemRESTHandler.SCHEMA()
payload = request.get('payload')
update_dict = transforms.json_to_dict(transforms.loads(payload),
schema.get_json_schema_dict())
# Get the teacher's user_id
user = Student.get_first_by_email(
update_dict['email'])[0] # returns a tuple
if not user:
transforms.send_json_response(
self, 404, 'MobileCSP: No registered user found for ' +
update_dict['email'], {'key': key})
return
# Check that the teacher isn't already registered
if update_dict['mode'] == 'Add':
teachers = TeacherEntity.get_teachers()
for teacher in teachers:
if teacher.email == update_dict['email']:
transforms.send_json_response(
self, 404,
'MobileCSP: User is already registered as a teacher ' +
update_dict['email'], {'key': key})
return
if GLOBAL_DEBUG:
logging.debug('****RAM**** teacher id ' + str(user.user_id))
# Store the user_id
update_dict['user_id'] = user.user_id
transforms.dict_to_entity(entity, update_dict)
entity.put()
transforms.send_json_response(self, 200, 'Saved.')
def put(self):
"""Handles REST PUT verb with JSON payload."""
request = transforms.loads(self.request.get('request'))
key = request.get('key')
if not self.assert_xsrf_token_or_fail(
request, 'announcement-put', {'key': key}):
return
if not AnnouncementsRights.can_edit(self):
transforms.send_json_response(
self, 401, 'Access denied.', {'key': key})
return
entity = AnnouncementEntity.get(key)
if not entity:
transforms.send_json_response(
self, 404, 'Object not found.', {'key': key})
return
payload = request.get('payload')
transforms.dict_to_entity(entity, transforms.json_to_dict(
transforms.loads(payload),
AnnouncementsItemRESTHandler.SCHEMA_DICT))
entity.put()
email_sent = False
#if entity.send_email:
# email_manager = notify.EmailManager(self.get_course())
# email_sent = email_manager.send_announcement(
# entity.title, entity.html)
#if entity.send_email and not email_sent:
# if not self.get_course().get_course_announcement_list_email():
# message = 'Saved. Announcement list not configured.'
# else:
# message = 'Saved, but there was an error sending email.'
#else:
# message = 'Saved.'
if entity.send_email and not entity.is_draft:
# get all students email
all_students = self.get_students()
email_list = []
recipient = ""
for s in all_students:
if s.is_enrolled and s.email != "*****@*****.**":
recipient = s.name + "<" + s.email + ">"
email_list.append(recipient)
# send an announcement email
sender_address = "X-Informatics <*****@*****.**>"
user_address = email_list
subject = "X-Informatics Announcement: " + entity.title
body = ""
html = entity.html
mail.send_mail(sender_address, user_address, subject, body, html=html)
if entity.send_email:
message = 'Saved and sent.'
else:
message = 'Saved.'
transforms.send_json_response(self, 200, message)
