def test_reject_bad_number(self): schema = wrap_properties({'field': {'type': 'number'}}) source = {'field': 'cat'} try: transforms.json_to_dict(source, schema) self.fail('Expected ValueException') except ValueError as e: self.assertEqual(str(e), 'could not convert string to float: cat')
def test_reject_bad_boolean(self): schema = wrap_properties({'field': {'type': 'boolean'}}) source = {'field': 'cat'} try: transforms.json_to_dict(source, schema) self.fail('Expected ValueException') except ValueError as e: self.assertEqual(str(e), 'Bad boolean value for field: cat')
def test_convert_date(self): schema = wrap_properties({'field': {'type': 'date'}}) source = {'field': '2005/03/01'} result = transforms.json_to_dict(source, schema) self.assertEqual(len(result), 1) self.assertEqual(result['field'], datetime.date(2005, 3, 1)) source = {'field': '2005-03-01'} result = transforms.json_to_dict(source, schema) self.assertEqual(result['field'], datetime.date(2005, 3, 1))
def put(self): """A PUT REST method shared by all unit types.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail( request, 'put-unit', {'key': key}): return if not CourseOutlineRights.can_edit(self): transforms.send_json_response( self, 401, 'Access denied.', {'key': key}) return unit = courses.Course(self).find_unit_by_id(key) if not unit: transforms.send_json_response( self, 404, 'Object not found.', {'key': key}) return payload = request.get('payload') updated_unit_dict = transforms.json_to_dict( transforms.loads(payload), self.SCHEMA_DICT) errors = [] self.apply_updates(unit, updated_unit_dict, errors) if not errors: course = courses.Course(self) assert course.update_unit(unit) course.save() common_utils.run_hooks(self.POST_SAVE_HOOKS, unit) transforms.send_json_response(self, 200, 'Saved.') else: transforms.send_json_response(self, 412, '\n'.join(errors))
def put(self): """A PUT REST method shared by all unit types.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail(request, 'put-unit', {'key': key}): return if not roles.Roles.is_course_admin(self.app_context): transforms.send_json_response(self, 401, 'Access denied.', {'key': key}) return course = courses.Course(self) unit = course.find_unit_by_id(key) if not unit: transforms.send_json_response(self, 404, 'Object not found.', {'key': key}) return payload = request.get('payload') updated_unit_dict = transforms.json_to_dict(transforms.loads(payload), self.get_schema_dict()) errors = [] self.apply_updates(course, unit, updated_unit_dict, errors) if not errors: transforms.send_json_response(self, 200, 'Saved.') else: transforms.send_json_response(self, 412, '\n'.join(errors))
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() transforms.send_json_response(self, 200, 'Saved.')
def put(self): """A PUT REST method shared by all unit types.""" request = transforms.loads(self.request.get("request")) key = request.get("key") if not self.assert_xsrf_token_or_fail(request, "put-unit", {"key": key}): return if not self.can_edit(self.app_context): transforms.send_json_response(self, 401, "Access denied.", {"key": key}) return unit = courses.Course(self).find_unit_by_id(key) if not unit: transforms.send_json_response(self, 404, "Object not found.", {"key": key}) return payload = request.get("payload") errors = [] course = courses.Course(self) try: schema = self.get_schema(course, key) updated_unit_dict = transforms.json_to_dict(transforms.loads(payload), schema.get_json_schema_dict()) schema.redact_entity_to_schema(updated_unit_dict) self.apply_updates(unit, updated_unit_dict, errors) except (TypeError, ValueError), ex: errors.append(str(ex))
def put(self): """Store a question group in the datastore in response to a PUT.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail( request, self.XSRF_TOKEN, {'key': key}): return if not CourseOutlineRights.can_edit(self): transforms.send_json_response( self, 401, 'Access denied.', {'key': key}) return payload = request.get('payload') question_group_dict = transforms.json_to_dict( transforms.loads(payload), self.get_schema().get_json_schema_dict()) validation_errors = self.validate(question_group_dict, key) if validation_errors: self.validation_error('\n'.join(validation_errors), key=key) return assert self.SCHEMA_VERSION == question_group_dict.get('version') if key: question_group = QuestionGroupDTO(key, question_group_dict) else: question_group = QuestionGroupDTO(None, question_group_dict) key_after_save = QuestionGroupDAO.save(question_group) transforms.send_json_response( self, 200, 'Saved.', payload_dict={'key': key_after_save})
def put(self): """A PUT REST method shared by all unit types.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail( request, 'put-unit', {'key': key}): return if not CourseOutlineRights.can_edit(self): transforms.send_json_response( self, 401, 'Access denied.', {'key': key}) return unit = courses.Course(self).find_unit_by_id(key) if not unit: transforms.send_json_response( self, 404, 'Object not found.', {'key': key}) return payload = request.get('payload') errors = [] try: updated_unit_dict = transforms.json_to_dict( transforms.loads(payload), self.SCHEMA_DICT) self.apply_updates(unit, updated_unit_dict, errors) except (TypeError, ValueError), ex: errors.append(str(ex))
def put(self): """A PUT REST method shared by all unit types.""" request = transforms.loads(self.request.get("request")) key = request.get("key") if not self.assert_xsrf_token_or_fail(request, "put-unit", {"key": key}): return if not CourseOutlineRights.can_edit(self): transforms.send_json_response(self, 401, "Access denied.", {"key": key}) return unit = courses.Course(self).find_unit_by_id(key) if not unit: transforms.send_json_response(self, 404, "Object not found.", {"key": key}) return payload = request.get("payload") updated_unit_dict = transforms.json_to_dict(transforms.loads(payload), self.SCHEMA_DICT) errors = [] self.apply_updates(unit, updated_unit_dict, errors) if not errors: course = courses.Course(self) assert course.update_unit(unit) course.save() transforms.send_json_response(self, 200, "Saved.") else: transforms.send_json_response(self, 412, "\n".join(errors))
def _add_query_filters(cls, source_context, schema, page_number, query): for filter_spec in source_context.filters: parts = cls.FILTER_RE.match(filter_spec) if not parts: raise ValueError( 'Filter specification "%s" ' % filter_spec + 'is not of the form: <name><op><value>') name, op, value = parts.groups() if op not in cls.SUPPORTED_OPERATIONS: raise ValueError( 'Filter specification "%s" ' % filter_spec + 'uses an unsupported comparison operation "%s"' % op) if name not in schema: raise ValueError( 'Filter specification "%s" ' % filter_spec + 'calls for field "%s" ' % name + 'which is not in the schema for ' 'type "%s"' % cls.get_entity_class().__name__) if value == '': converted_value = None else: converted_value = transforms.json_to_dict( {name: value}, {'properties': {name: schema[name]}})[name] query.filter('%s %s' % (name, op), converted_value)
def put(self): """Handles PUT REST verb to save lesson and associated activity.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail( request, 'lesson-edit', {'key': key}): return if not roles.Roles.is_course_admin(self.app_context): transforms.send_json_response( self, 401, 'Access denied.', {'key': key}) return course = courses.Course(self) lesson = course.find_lesson_by_id(None, key) if not lesson: transforms.send_json_response( self, 404, 'Object not found.', {'key': key}) return payload = request.get('payload') updates_dict = transforms.json_to_dict( transforms.loads(payload), self.get_schema(course, key).get_json_schema_dict()) lesson.title = updates_dict['title'] lesson.unit_id = updates_dict['unit_id'] lesson.scored = (updates_dict['scored'] == 'scored') lesson.objectives = updates_dict['objectives'] lesson.video = updates_dict['video'] lesson.notes = updates_dict['notes'] lesson.auto_index = updates_dict['auto_index'] lesson.activity_title = updates_dict['activity_title'] lesson.activity_listed = updates_dict['activity_listed'] lesson.manual_progress = updates_dict['manual_progress'] activity = updates_dict.get('activity', '').strip() errors = [] if activity: if lesson.has_activity: course.set_activity_content(lesson, activity, errors=errors) else: errors.append('Old-style activities are not supported.') else: lesson.has_activity = False fs = self.app_context.fs path = fs.impl.physical_to_logical(course.get_activity_filename( lesson.unit_id, lesson.lesson_id)) if fs.isfile(path): fs.delete(path) if not errors: common_utils.run_hooks(self.PRE_SAVE_HOOKS, lesson, updates_dict) assert course.update_lesson(lesson) course.save() common_utils.run_hooks(self.POST_SAVE_HOOKS, lesson) transforms.send_json_response(self, 200, 'Saved.') else: transforms.send_json_response(self, 412, '\n'.join(errors))
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) 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.""" if not CourseOutlineRights.can_edit(self): transforms.send_json_response(self, 401, "Access denied.", {}) return request = transforms.loads(self.request.get("request")) payload = request.get("payload") course_raw = transforms.json_to_dict(transforms.loads(payload), self.SCHEMA_DICT)["course"] source = None for acourse in sites.get_all_courses(): if acourse.raw == course_raw: source = acourse break if not source: transforms.send_json_response(self, 404, "Object not found.", {"raw": course_raw}) return course = courses.Course(self) errors = [] try: course.import_from(source, errors) except Exception as e: # pylint: disable-msg=broad-except logging.exception(e) errors.append("Import failed: %s" % e) if errors: transforms.send_json_response(self, 412, "\n".join(errors)) return course.save() transforms.send_json_response(self, 200, "Imported.")
def _import_and_validate15(self, unvalidated_dict, key): errors = [] try: question_dict = transforms.json_to_dict( unvalidated_dict, self.get_schema().get_json_schema_dict()) except ValueError as err: errors.append(str(err)) return (None, errors) if not question_dict['question'].strip(): errors.append('The question must have a non-empty body.') if not question_dict['description']: errors.append('The description must be non-empty.') self.validate_no_description_collision( question_dict['description'], key, errors) if not question_dict['graders']: errors.append('The question must have at least one answer.') graders = question_dict['graders'] for index in range(0, len(graders)): grader = graders[index] assert grader['matcher'] in [ matcher for (matcher, unused_text) in self.GRADER_TYPES] if not grader['response'].strip(): errors.append('Answer %s has no response text.' % (index + 1)) try: float(grader['score']) except ValueError: errors.append( 'Answer %s must have a numeric score.' % (index + 1)) return (question_dict, errors)
def _import_and_validate15(self, unvalidated_dict, key): errors = [] try: question_dict = transforms.json_to_dict( unvalidated_dict, self.get_schema().get_json_schema_dict()) except ValueError as err: errors.append(str(err)) return (None, errors) if not question_dict['question'].strip(): errors.append('The question must have a non-empty body.') if not question_dict['description']: errors.append('The description must be non-empty.') self.validate_no_description_collision( question_dict['description'], key, errors) if not question_dict['choices']: errors.append('The question must have at least one choice.') choices = question_dict['choices'] for index in range(0, len(choices)): choice = choices[index] if not choice['text'].strip(): errors.append('Choice %s has no response text.' % (index + 1)) try: # Coefrce the score attrib into a python float choice['score'] = float(choice['score']) except ValueError: errors.append( 'Choice %s must have a numeric score.' % (index + 1)) return (question_dict, errors)
def test_missing_required_fields_are_rejected(self): schema = wrap_properties( {'req_field': {'type': 'boolean', 'optional': 'false'}}) try: transforms.json_to_dict({}, schema) self.fail('Expected ValueError') except ValueError as e: self.assertEqual(str(e), 'Missing required attribute: req_field') schema = wrap_properties( {'req_field': {'type': 'boolean'}}) try: transforms.json_to_dict({}, schema) self.fail('Expected ValueError') except ValueError as e: self.assertEqual(str(e), 'Missing required attribute: req_field')
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 test_missing_optional_fields_are_allowed(self): schema = wrap_properties( {'opt_field': { 'type': 'boolean', 'optional': 'true' }}) result = transforms.json_to_dict({}, schema) self.assertEqual(len(result), 0)
def test_reject_bad_dates(self): schema = wrap_properties({'field': {'type': 'date'}}) source = {'field': '2005/02/31'} try: transforms.json_to_dict(source, schema) self.fail('Expected ValueException') except ValueError as e: self.assertEqual(str(e), 'day is out of range for month') schema = wrap_properties({'field': {'type': 'date'}}) source = {'field': 'cat'} try: transforms.json_to_dict(source, schema) self.fail('Expected ValueException') except ValueError as e: self.assertEqual( str(e), 'time data \'cat\' does not match format \'%Y/%m/%d\'')
def json_to_list(cls, json_str): if not json_str: return [] json_dicts = transforms.loads(json_str) parsed_dicts = [ transforms.json_to_dict(d, cls.SCHEMA.get_json_schema_dict()) for d in json_dicts] return [cls(**kwargs) for kwargs in parsed_dicts]
def test_nulls(self): for type_name in transforms.JSON_TYPES: schema = wrap_properties({'field': {'type': type_name}}) source = {'field': None} ret = transforms.json_to_dict(source, schema, permit_none_values=True) self.assertIn('field', ret) self.assertIsNone(ret['field'])
def post(self): name = COURSE_EXPLORER_SETTINGS.name request = transforms.loads(self.request.get('request')) if not self.assert_xsrf_token_or_fail(request, self.ACTION, {}): return if not roles.Roles.is_course_admin(self.app_context): transforms.send_json_response(self, 401, 'Access denied.', {}) return raw_data = transforms.loads(request.get('payload')) raw_data.pop('logo', None) try: data = transforms.json_to_dict( raw_data, schema_provider(None).get_json_schema_dict()) except (TypeError, ValueError) as err: self.validation_error(err.replace('\n', ' ')) return logo = self.request.POST.get('logo') logo_uploaded = isinstance(logo, cgi.FieldStorage) if logo_uploaded: data['logo_bytes_base64'] = base64.b64encode(logo.file.read()) data['logo_mime_type'] = logo.type with common_utils.Namespace(appengine_config.DEFAULT_NAMESPACE_NAME): entity = config.ConfigPropertyEntity.get_by_key_name(name) if entity is None: entity = config.ConfigPropertyEntity(key_name=name) old_value = None else: old_value = entity.value # Don't delete the logo. if not logo_uploaded and old_value: old_dict = transforms.loads(old_value) if ('logo_bytes_base64' in old_dict and 'logo_mime_type' in old_dict): data['logo_bytes_base64'] = old_dict['logo_bytes_base64'] data['logo_mime_type'] = old_dict['logo_mime_type'] entity.value = transforms.dumps(data) entity.is_draft = False entity.put() # is this necessary? models.EventEntity.record( 'put-property', users.get_current_user(), transforms.dumps({ 'name': name, 'before': str(old_value), 'after': str(entity.value) })) transforms.send_file_upload_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 test_missing_required_fields_are_rejected(self): schema = wrap_properties( {'req_field': { 'type': 'boolean', 'optional': 'false' }}) try: transforms.json_to_dict({}, schema) self.fail('Expected ValueError') except ValueError as e: self.assertEqual(str(e), 'Missing required attribute: req_field') schema = wrap_properties({'req_field': {'type': 'boolean'}}) try: transforms.json_to_dict({}, schema) self.fail('Expected ValueError') except ValueError as e: self.assertEqual(str(e), 'Missing required attribute: req_field')
def json_to_list(cls, json_str): if not json_str: return [] json_dicts = transforms.loads(json_str) parsed_dicts = [ transforms.json_to_dict(d, cls.SCHEMA.get_json_schema_dict()) for d in json_dicts ] return [cls(**kwargs) for kwargs in parsed_dicts]
def put(self): """Handles PUT REST verb to save lesson and associated activity.""" request = transforms.loads(self.request.get("request")) key = request.get("key") if not self.assert_xsrf_token_or_fail(request, "lesson-edit", {"key": key}): return if not roles.Roles.is_course_admin(self.app_context): transforms.send_json_response(self, 401, "Access denied.", {"key": key}) return course = courses.Course(self) lesson = course.find_lesson_by_id(None, key) if not lesson: transforms.send_json_response(self, 404, "Object not found.", {"key": key}) return payload = request.get("payload") updates_dict = transforms.json_to_dict( transforms.loads(payload), self.get_schema(course, key).get_json_schema_dict() ) lesson.title = updates_dict["title"] lesson.unit_id = updates_dict["unit_id"] lesson.scored = updates_dict["scored"] == "scored" lesson.objectives = updates_dict["objectives"] lesson.video = updates_dict["video"] lesson.notes = updates_dict["notes"] lesson.auto_index = updates_dict["auto_index"] lesson.activity_title = updates_dict["activity_title"] lesson.activity_listed = updates_dict["activity_listed"] lesson.manual_progress = updates_dict["manual_progress"] lesson.now_available = not updates_dict["is_draft"] activity = updates_dict.get("activity", "").strip() errors = [] if activity: if lesson.has_activity: course.set_activity_content(lesson, activity, errors=errors) else: errors.append("Old-style activities are not supported.") else: lesson.has_activity = False fs = self.app_context.fs path = fs.impl.physical_to_logical(course.get_activity_filename(lesson.unit_id, lesson.lesson_id)) if fs.isfile(path): fs.delete(path) if not errors: common_utils.run_hooks(self.PRE_SAVE_HOOKS, lesson, updates_dict) assert course.update_lesson(lesson) course.save() common_utils.run_hooks(self.POST_SAVE_HOOKS, lesson) transforms.send_json_response(self, 200, "Saved.") else: transforms.send_json_response(self, 412, "\n".join(errors))
def post(self): name = COURSE_EXPLORER_SETTINGS.name request = transforms.loads(self.request.get('request')) if not self.assert_xsrf_token_or_fail( request, self.ACTION, {}): return if not roles.Roles.is_course_admin(self.app_context): transforms.send_json_response( self, 401, 'Access denied.', {}) return raw_data = transforms.loads(request.get('payload')) raw_data.pop('logo', None) try: data = transforms.json_to_dict( raw_data, schema_provider(None).get_json_schema_dict()) except (TypeError, ValueError) as err: self.validation_error(err.replace('\n', ' ')) return logo = self.request.POST.get('logo') logo_uploaded = isinstance(logo, cgi.FieldStorage) if logo_uploaded: data['logo_bytes_base64'] = base64.b64encode(logo.file.read()) data['logo_mime_type'] = logo.type with common_utils.Namespace(appengine_config.DEFAULT_NAMESPACE_NAME): entity = config.ConfigPropertyEntity.get_by_key_name(name) if entity is None: entity = config.ConfigPropertyEntity(key_name=name) old_value = None else: old_value = entity.value # Don't delete the logo. if not logo_uploaded and old_value: old_dict = transforms.loads(old_value) if ( 'logo_bytes_base64' in old_dict and 'logo_mime_type' in old_dict): data['logo_bytes_base64'] = old_dict['logo_bytes_base64'] data['logo_mime_type'] = old_dict['logo_mime_type'] entity.value = transforms.dumps(data) entity.is_draft = False entity.put() # is this necessary? models.EventEntity.record( 'put-property', users.get_current_user(), transforms.dumps({ 'name': name, 'before': str(old_value), 'after': str(entity.value)})) transforms.send_file_upload_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') 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): """Store a DTO in the datastore in response to a PUT.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not key and not self.CAN_CREATE: transforms.send_json_response(self, 404, 'Key is required in URL.', {}) return if not self.assert_xsrf_token_or_fail(request, self.XSRF_TOKEN, {'key': key}): return if not roles.Roles.is_course_admin(self.app_context): transforms.send_json_response(self, 401, 'Access denied.', {'key': key}) return payload = request.get('payload') json_dict = transforms.loads(payload) self.sanitize_input_dict(json_dict) errors = [] try: python_dict = transforms.json_to_dict( json_dict, self.get_schema().get_json_schema_dict()) version = python_dict.get('version') if version not in self.SCHEMA_VERSIONS: errors.append('Version %s not supported.' % version) else: python_dict = self.transform_after_editor_hook(python_dict) self.validate(python_dict, key, version, errors) common_utils.run_hooks(self.VALIDATE_HOOKS, python_dict, key, version, errors) except (TypeError, ValueError) as err: errors.append(str(err)) if errors: self.validation_error('\n'.join( error.replace('\n', ' ') for error in errors), key=key) return item = self.get_and_populate_dto(key, python_dict) self.pre_save_hook(item) common_utils.run_hooks(self.PRE_SAVE_HOOKS, item, python_dict) key_after_save = self.DAO.save(item) self.after_save_hook() transforms.send_json_response(self, 200, 'Saved.', payload_dict={'key': key_after_save})
def _import_and_validate15(self, unvalidated_dict, key): errors = [] try: question_dict = transforms.json_to_dict( unvalidated_dict, self.get_schema().get_json_schema_dict()) except ValueError as err: errors.append(str(err)) return (None, errors) if not question_dict['question'].strip(): errors.append('The question must have a non-empty body.') if not question_dict['description']: errors.append('The description must be non-empty.') self.validate_no_description_collision(question_dict['description'], key, errors) try: # Coerce the rows attrib into a python int question_dict['rows'] = int(question_dict['rows']) if question_dict['rows'] <= 0: errors.append('Rows must be a positive whole number') except ValueError: errors.append('Rows must be a whole number') try: # Coerce the cols attrib into a python int question_dict['columns'] = int(question_dict['columns']) if question_dict['columns'] <= 0: errors.append('Columns must be a positive whole number') except ValueError: errors.append('Columns must be a whole number') if not question_dict['graders']: errors.append('The question must have at least one answer.') graders = question_dict['graders'] for index in range(0, len(graders)): grader = graders[index] assert grader['matcher'] in [ matcher for (matcher, unused_text) in self.GRADER_TYPES ] if not grader['response'].strip(): errors.append('Answer %s has no response text.' % (index + 1)) try: float(grader['score']) except ValueError: errors.append('Answer %s must have a numeric score.' % (index + 1)) return (question_dict, errors)
def put(self): """Handles PUT REST verb to save lesson and associated activity.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail(request, 'lesson-edit', {'key': key}): return if not CourseOutlineRights.can_edit(self): transforms.send_json_response(self, 401, 'Access denied.', {'key': key}) return course = courses.Course(self) lesson = course.find_lesson_by_id(None, key) if not lesson: transforms.send_json_response(self, 404, 'Object not found.', {'key': key}) return payload = request.get('payload') updates_dict = transforms.json_to_dict(transforms.loads(payload), self.SCHEMA_DICT) lesson.title = updates_dict['title'] lesson.unit_id = updates_dict['unit_id'] lesson.objectives = updates_dict['objectives'] lesson.video = updates_dict['video'] lesson.notes = updates_dict['notes'] lesson.activity_title = updates_dict['activity_title'] lesson.activity_listed = updates_dict['activity_listed'] lesson.now_available = not updates_dict['is_draft'] activity = updates_dict.get('activity', '').strip() errors = [] if activity: lesson.has_activity = True course.set_activity_content(lesson, activity, errors=errors) else: lesson.has_activity = False fs = self.app_context.fs path = fs.impl.physical_to_logical( course.get_activity_filename(lesson.unit_id, lesson.lesson_id)) if fs.isfile(path): fs.delete(path) if not errors: assert course.update_lesson(lesson) course.save() transforms.send_json_response(self, 200, 'Saved.') else: transforms.send_json_response(self, 412, '\n'.join(errors))
def put(self): """Handles PUT REST verb to save lesson and associated activity.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail( request, 'lesson-edit', {'key': key}): return if not CourseOutlineRights.can_edit(self): transforms.send_json_response( self, 401, 'Access denied.', {'key': key}) return course = courses.Course(self) lesson = course.find_lesson_by_id(None, key) if not lesson: transforms.send_json_response( self, 404, 'Object not found.', {'key': key}) return payload = request.get('payload') updates_dict = transforms.json_to_dict( transforms.loads(payload), self.SCHEMA_DICT) lesson.title = updates_dict['title'] lesson.unit_id = updates_dict['unit_id'] lesson.objectives = updates_dict['objectives'] lesson.video = updates_dict['video'] lesson.notes = updates_dict['notes'] lesson.activity_title = updates_dict['activity_title'] lesson.activity_listed = updates_dict['activity_listed'] lesson.now_available = not updates_dict['is_draft'] activity = updates_dict.get('activity', '').strip() errors = [] if activity: lesson.has_activity = True course.set_activity_content(lesson, activity, errors=errors) else: lesson.has_activity = False fs = self.app_context.fs path = fs.impl.physical_to_logical(course.get_activity_filename( lesson.unit_id, lesson.lesson_id)) if fs.isfile(path): fs.delete(path) if not errors: assert course.update_lesson(lesson) course.save() transforms.send_json_response(self, 200, 'Saved.') else: transforms.send_json_response(self, 412, '\n'.join(errors))
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): """Store a DTO in the datastore in response to a PUT.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not key and not self.CAN_CREATE: transforms.send_json_response( self, 404, 'Key is required in URL.', {}) return if not self.assert_xsrf_token_or_fail( request, self.XSRF_TOKEN, {'key': key}): return if not roles.Roles.is_course_admin(self.app_context): transforms.send_json_response( self, 401, 'Access denied.', {'key': key}) return payload = request.get('payload') json_dict = transforms.loads(payload) self.sanitize_input_dict(json_dict) errors = [] try: python_dict = transforms.json_to_dict( json_dict, self.get_schema().get_json_schema_dict()) version = python_dict.get('version') if version not in self.SCHEMA_VERSIONS: errors.append('Version %s not supported.' % version) else: python_dict = self.transform_after_editor_hook(python_dict) self.validate(python_dict, key, version, errors) common_utils.run_hooks( self.VALIDATE_HOOKS, python_dict, key, version, errors) except (TypeError, ValueError) as err: errors.append(str(err)) if errors: self.validation_error('\n'.join( error.replace('\n', ' ') for error in errors), key=key) return item = self.get_and_populate_dto(key, python_dict) self.pre_save_hook(item) common_utils.run_hooks(self.PRE_SAVE_HOOKS, item, python_dict) key_after_save = self.DAO.save(item) self.after_save_hook() transforms.send_json_response( self, 200, 'Saved.', payload_dict={'key': key_after_save})
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 test_convert_datetime(self): schema = wrap_properties({'field': {'type': 'datetime'}}) source = {'field': '2005/03/01 20:30'} result = transforms.json_to_dict(source, schema) self.assertEqual(len(result), 1) self.assertEqual( result['field'], datetime.datetime(2005, 3, 1, 20, 30, 0)) source = {'field': '2005-03-01 20:30:19'} result = transforms.json_to_dict(source, schema) self.assertEqual( result['field'], datetime.datetime(2005, 3, 1, 20, 30, 19)) source = {'field': '2005-03-01 20:30:19Z'} result = transforms.json_to_dict(source, schema) self.assertEqual( result['field'], datetime.datetime(2005, 3, 1, 20, 30, 19)) source = {'field': '2005-03-01T20:30:19.123456Z'} result = transforms.json_to_dict(source, schema) self.assertEqual( result['field'], datetime.datetime(2005, 3, 1, 20, 30, 19, 123456))
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 test_array_of_string(self): reg = schema_fields.FieldRegistry('Test') reg.add_property(schema_fields.FieldArray( 'string_array', 'String Array', item_type=schema_fields.SchemaField(None, None, 'string'), select_data=(('one', 'One'), ('two', 'Two'), ('three', 'Three')))) json_schema = reg.get_json_schema_dict() source = {'string_array': ['one', 'two']} self.assertEqual(transforms.validate_object_matches_json_schema( source, json_schema), []) self.assertEqual(transforms.json_to_dict(source, json_schema), source)
def put(self): """Store a DTO in the datastore in response to a PUT.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail(request, self.XSRF_TOKEN, {'key': key}): return if not roles.Roles.is_course_admin(self.app_context): transforms.send_json_response(self, 401, 'Access denied.', {'key': key}) return payload = request.get('payload') json_dict = transforms.loads(payload) self.sanitize_input_dict(json_dict) errors = [] try: python_dict = transforms.json_to_dict( json_dict, self.get_schema().get_json_schema_dict()) version = python_dict.get('version') if version not in self.SCHEMA_VERSIONS: errors.append('Version %s not supported.' % version) else: python_dict = self.transform_after_editor_hook(python_dict) self.validate(python_dict, key, version, errors) except ValueError as err: errors.append(str(err)) if errors: self.validation_error('\n'.join(errors), key=key) return if key: item = self.DAO.DTO(key, python_dict) else: item = self.DAO.DTO(None, python_dict) self.pre_save_hook(item) key_after_save = self.DAO.save(item) self.after_save_hook() transforms.send_json_response(self, 200, 'Saved.', payload_dict={'key': key_after_save})
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 PUT REST verb to save lesson and associated activity.""" request = transforms.loads(self.request.get("request")) key = request.get("key") if not self.assert_xsrf_token_or_fail(request, "lesson-edit", {"key": key}): return if not CourseOutlineRights.can_edit(self): transforms.send_json_response(self, 401, "Access denied.", {"key": key}) return course = courses.Course(self) lesson = course.find_lesson_by_id(None, key) if not lesson: transforms.send_json_response(self, 404, "Object not found.", {"key": key}) return payload = request.get("payload") updates_dict = transforms.json_to_dict(transforms.loads(payload), self.SCHEMA_DICT) lesson.title = updates_dict["title"] lesson.unit_id = updates_dict["unit_id"] lesson.objectives = updates_dict["objectives"] lesson.video = updates_dict["video"] lesson.notes = updates_dict["notes"] lesson.activity_title = updates_dict["activity_title"] lesson.now_available = not updates_dict["is_draft"] activity = updates_dict.get("activity", "").strip() errors = [] if activity: lesson.has_activity = True course.set_activity_content(lesson, activity, errors=errors) else: lesson.has_activity = False fs = self.app_context.fs path = fs.impl.physical_to_logical(course.get_activity_filename(lesson.unit_id, lesson.lesson_id)) if fs.isfile(path): fs.delete(path) if not errors: assert course.update_lesson(lesson) course.save() transforms.send_json_response(self, 200, "Saved.") else: transforms.send_json_response(self, 412, "\n".join(errors))
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')) if not self.assert_xsrf_token_or_fail(request, self.ACTION, {'key': None}): return if not roles.Roles.is_course_admin(self.app_context): transforms.send_json_response(self, 401, 'Access denied.', {}) return payload = request.get('payload') course_raw = transforms.json_to_dict(transforms.loads(payload), self.SCHEMA_DICT)['course'] source = None for acourse in sites.get_all_courses(): if acourse.raw == course_raw: source = acourse break if not source: transforms.send_json_response(self, 404, 'Object not found.', {'raw': course_raw}) return import_job = ImportCourseBackgroundJob(self.app_context, source.get_namespace_name()) if import_job.is_active(): transforms.send_json_response(self, 503, 'Import already in progress.', {'raw': course_raw}) return try: status = import_job.submit() error_starting = (status < 0) except Exception: # pylint: disable=broad-except error_starting = True if error_starting: transforms.send_json_response(self, 500, 'Could not start import.', {'raw': course_raw}) return transforms.send_json_response(self, 200, 'Importing.')
def put(self): """Store a QuestionGroupDTO and QuestionDTO in the datastore.""" request = transforms.loads(self.request.get('request')) if not self.assert_xsrf_token_or_fail(request, self.XSRF_TOKEN, {'key': None}): return if not roles.Roles.is_course_admin(self.app_context): transforms.send_json_response(self, 401, 'Access denied.') return payload = request.get('payload') json_dict = transforms.loads(payload) errors = [] try: python_dict = transforms.json_to_dict( json_dict, self.get_schema().get_json_schema_dict()) questions = gift.GiftParser.parse_questions( python_dict['questions']) self.validate_question_descriptions(questions, errors) description = python_dict['description'] if description: self.validate_group_description(description, errors) if not errors: dtos = self.convert_to_dtos(questions) question_ids = models.QuestionDAO.save_all(dtos) if description: self.create_group(description, question_ids) except ValueError as e: errors.append(str(e)) except gift.ParseError as e: errors.append(str(e)) except models.CollisionError as e: errors.append(str(e)) if errors: self.validation_error('\n'.join(errors)) return msg = 'Saved: %s.' % python_dict['description'] transforms.send_json_response(self, 200, msg) return
def put(self): request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail(request, self.XSRF_TOKEN, {}): return if not roles.Roles.is_course_admin(self.app_context): transforms.send_json_response(self, 401, 'Access denied.', {'key': key}) return payload = request.get('payload') json_dict = transforms.loads(payload) python_dict = transforms.json_to_dict( json_dict, self.get_schema().get_json_schema_dict(), permit_none_values=True) version = python_dict.get('version') if version not in self.SCHEMA_VERSIONS: self.validation_error('Version %s not supported.' % version) return errors = [] if key: key_after_save = SkillGraph.load().update(key, python_dict, errors) else: skill = Skill.build(python_dict.get('name'), python_dict.get('description'), python_dict.get('prerequisites')) key_after_save = SkillGraph.load().add(skill, errors=errors).id if errors: self.validation_error('\n'.join(errors), key=key) return transforms.send_json_response(self, 200, 'Saved.', payload_dict={'key': key_after_save})
def put(self): """Handles REST PUT verb with JSON payload.""" request = transforms.loads(self.request.get('request')) if not self.assert_xsrf_token_or_fail(request, 'unit-lesson-reorder', {'key': None}): return if not CourseOutlineRights.can_edit(self): transforms.send_json_response(self, 401, 'Access denied.', {}) return payload = request.get('payload') payload_dict = transforms.json_to_dict(transforms.loads(payload), self.SCHEMA_DICT) course = courses.Course(self) course.reorder_units(payload_dict['outline']) course.save() transforms.send_json_response(self, 200, 'Saved.')
def put(self): """Handles REST PUT verb with JSON payload.""" request = transforms.loads(self.request.get('request')) if not self.assert_xsrf_token_or_fail(request, 'import-course', {'key': None}): return if not CourseOutlineRights.can_edit(self): transforms.send_json_response(self, 401, 'Access denied.', {}) return payload = request.get('payload') course_raw = transforms.json_to_dict(transforms.loads(payload), self.SCHEMA_DICT)['course'] source = None for acourse in sites.get_all_courses(): if acourse.raw == course_raw: source = acourse break if not source: transforms.send_json_response(self, 404, 'Object not found.', {'raw': course_raw}) return course = courses.Course(self) errors = [] try: course.import_from(source, errors) except Exception as e: # pylint: disable=broad-except logging.exception(e) errors.append('Import failed: %s' % e) if errors: transforms.send_json_response(self, 412, '\n'.join(errors)) return course.save() transforms.send_json_response(self, 200, 'Imported.')
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): """A PUT REST method shared by all unit types.""" request = transforms.loads(self.request.get('request')) if not self.assert_xsrf_token_or_fail(request, 'update_queue_settings', {}): return if not roles.Roles.is_super_admin(): transforms.send_json_response(self, 401, 'Access denied.') return payload = request.get('payload') updated_dict = transforms.json_to_dict(transforms.loads(payload), self.get_schema_dict()) errors = [] self.apply_updates(updated_dict, errors) if not errors: transforms.send_json_response(self, 200, 'Saved.') else: transforms.send_json_response(self, 412, '\n'.join(errors))
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 _add_query_filters(cls, source_context, schema, page_number, query): for filter_spec in source_context.filters: parts = cls.FILTER_RE.match(filter_spec) if not parts: raise ValueError('Filter specification "%s" ' % filter_spec + 'is not of the form: <name><op><value>') name, op, value = parts.groups() if op not in cls.SUPPORTED_OPERATIONS: raise ValueError( 'Filter specification "%s" ' % filter_spec + 'uses an unsupported comparison operation "%s"' % op) if name not in schema: raise ValueError('Filter specification "%s" ' % filter_spec + 'calls for field "%s" ' % name + 'which is not in the schema for ' 'type "%s"' % cls.get_entity_class().__name__) converted_value = transforms.json_to_dict( {name: value}, {'properties': { name: schema[name] }})[name] query.filter('%s %s' % (name, op), converted_value)
def put(self): """Handles REST PUT verb with JSON payload.""" request = transforms.loads(self.request.get('request')) if not self.assert_xsrf_token_or_fail(request, self.XSRF_TOKEN, {'key': None}): return if not roles.Roles.is_user_allowed( self.app_context, custom_module, constants.COURSE_OUTLINE_REORDER_PERMISSION): transforms.send_json_response(self, 401, 'Access denied.', {}) return payload = request.get('payload') payload_dict = transforms.json_to_dict(transforms.loads(payload), self.SCHEMA_DICT) course = courses.Course(self) course.reorder_units(payload_dict['outline']) course.save() transforms.send_json_response(self, 200, 'Saved.')
def put(self): """Store a question group in the datastore in response to a PUT.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail(request, self.XSRF_TOKEN, {'key': key}): return if not CourseOutlineRights.can_edit(self): transforms.send_json_response(self, 401, 'Access denied.', {'key': key}) return payload = request.get('payload') question_group_dict = transforms.json_to_dict( transforms.loads(payload), self.get_schema().get_json_schema_dict()) validation_errors = self.validate(question_group_dict, key) if validation_errors: self.validation_error('\n'.join(validation_errors), key=key) return assert self.SCHEMA_VERSION == question_group_dict.get('version') if key: question_group = QuestionGroupDTO(key, question_group_dict) else: question_group = QuestionGroupDTO(None, question_group_dict) key_after_save = QuestionGroupDAO.save(question_group) transforms.send_json_response(self, 200, 'Saved.', payload_dict={'key': key_after_save})
def post(self): """POST method called when the student submits answers.""" # I18N: Message to show the user was not allowed to access to resource access_denied = self.gettext('Access denied.') # I18N: Message to acknowledge successful submission of the # questionnaire response_submitted = self.gettext('Response submitted.') request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail( request, QUESTIONNAIRE_XSRF_TOKEN_NAME, {}): return user = self.get_user() if user is None: transforms.send_json_response(self, 401, access_denied, {}) return student = models.Student.get_enrolled_student_by_user(user) if student is None: transforms.send_json_response(self, 401, access_denied, {}) return payload_json = request.get('payload') payload_dict = transforms.json_to_dict(payload_json, self.SCHEMA) form_data = StudentFormEntity.load_or_default(student, key) form_data.value = transforms.dumps(payload_dict) form_data.put() transforms.send_json_response(self, 200, response_submitted)