def _save_template_version(request, assets, context, template_version_manager): """Save a template version. Args: request: assets: context: template_version_manager: Returns: """ # get the file from the form xsd_file = request.FILES['xsd_file'] # read the content of the file xsd_data = read_xsd_file(xsd_file) try: template = Template(filename=xsd_file.name, content=xsd_data) template_version_manager_api.insert(template_version_manager, template) return HttpResponseRedirect( reverse("admin:core_main_app_manage_template_versions", kwargs={ 'version_manager_id': str(template_version_manager.id) })) except exceptions.XSDError, xsd_error: return handle_xsd_errors(request, assets, context, xsd_error, xsd_data, xsd_file.name)
def _save_template(request, assets, context): """Save a template. Args: request: assets: context: Returns: """ # get the schema name name = request.POST['name'] # get the file from the form xsd_file = request.FILES['upload_file'] # read the content of the file xsd_data = read_xsd_file(xsd_file) try: template = Template(filename=xsd_file.name, content=xsd_data) template_version_manager = TemplateVersionManager(title=name) template_version_manager_api.insert(template_version_manager, template) return HttpResponseRedirect(reverse("admin:core_main_app_templates")) except exceptions.XSDError, xsd_error: return handle_xsd_errors(request, assets, context, xsd_error, xsd_data, xsd_file.name)
def _save_template(request, assets, context): """Save a template. Args: request: assets: context: Returns: """ # get the schema name name = request.POST['name'] # get the file from the form xsd_file = request.FILES['upload_file'] # read the content of the file xsd_data = read_xsd_file(xsd_file) try: template = Template(filename=xsd_file.name, content=xsd_data) template_version_manager = TemplateVersionManager(title=name) template_version_manager_api.insert(template_version_manager, template) return HttpResponseRedirect(reverse("admin:core_main_app_templates")) except exceptions.XSDError as xsd_error: return handle_xsd_errors(request, assets, context, xsd_error, xsd_data, xsd_file.name) except exceptions.NotUniqueError: context['errors'] = html_escape( "A template with the same name already exists. Please choose another name." ) return _upload_template_response(request, assets, context) except Exception as e: context['errors'] = html_escape(str(e)) return _upload_template_response(request, assets, context)
def _add_template(): """Add the registry template. Returns: """ xsd_filepath = REGISTRY_XSD_FILEPATH xsd_filename = REGISTRY_XSD_FILENAME if xsd_filename == "": raise Exception( "Please configure the REGISTRY_XSD_FILENAME setting in your project." ) if xsd_filepath == "": raise Exception( "Please configure the REGISTRY_XSD_FILEPATH setting in your project." ) try: version_manager_api.get_active_global_version_manager_by_title( xsd_filename) except exceptions.DoesNotExist: default_xsd_path = finders.find(xsd_filepath) xsd_data = read_file_content(default_xsd_path) template = Template(filename=xsd_filename, content=xsd_data) template_version_manager = TemplateVersionManager(title=xsd_filename) template_version_manager_api.insert(template_version_manager, template) except Exception as e: logger.error("Impossible to add the template: {0}".format(str(e)))
def create(self, validated_data): """ Create and return a new `Template` instance, given the validated data. """ template_object = Template( filename=validated_data["filename"], content=validated_data["content"], user=validated_data["user"], ) template_version_manager_object = validated_data["template_version_manager"] # load dependencies dependencies_dict = load_dependencies(validated_data) # Update the content of the template with dependencies init_template_with_dependencies( template_object, dependencies_dict, request=self.context["request"] ) # Create the template and its template version manager template_version_manager_api.insert( template_version_manager_object, template_object, request=self.context["request"], ) return template_object
def resolve_dependencies(request): """Resolve import/includes to avoid local references. Args: request: Returns: """ try: # Get the parameters name = request.POST.get('name', None) version_manager_id = request.POST.get('version_manager_id', '') filename = request.POST['filename'] xsd_content = request.POST['xsd_content'] schema_locations = request.POST.getlist('schemaLocations[]') dependencies = request.POST.getlist('dependencies[]') # create new object template = Template(filename=filename, content=_get_xsd_content_from_html(xsd_content)) init_template_with_dependencies( template, _get_dependencies_dict(schema_locations, dependencies)) # get the version manager or create a new one if version_manager_id != '': template_version_manager = version_manager_api.get( version_manager_id) else: template_version_manager = TemplateVersionManager(title=name) template_version_manager_api.insert(template_version_manager, template) except Exception, e: return HttpResponseBadRequest(e.message)
def test_insert_global_template_as_user_raises_access_control_error(self): mock_request = create_mock_request(user=self.user1) with self.assertRaises(AccessControlError): template_vm_api.insert( self.fixture.global_tvm, self.fixture.global_template, request=mock_request, )
def test_create_version_manager_raises_exception_if_error_in_create_template(self, mock_save): # Arrange template_filename = "schema.xsd" template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>" template = _create_template(template_filename, template_content) mock_version_manager = _create_mock_template_version_manager(title="Schema") mock_save.side_effect = django_exceptions.ValidationError("") # Act + Assert with self.assertRaises(django_exceptions.ValidationError): version_manager_api.insert(mock_version_manager, template)
def save_template(request): """Save the current template in the database. Args: request: Returns: """ try: template_name = request.POST['templateName'] xsd_string = request.session['newXmlTemplateCompose'] response_dict = {} try: # Build XSD tree xsd_tree = XSDTree.build_tree(xsd_string) # validate the schema error = main_xml_utils.validate_xml_schema(xsd_tree) if error is not None: return _error_response('This is not a valid XML schema. ' + error) except Exception, e: return _error_response('This is not a valid XML schema. ' + e.message) # get list of dependencies dependencies = _get_dependencies_ids( request.session["includedTypesCompose"]) try: # create template version manager template_version_manager = TemplateVersionManager( title=template_name, user=str(request.user.id)) # create template template = Template(filename=template_name, content=xsd_string, dependencies=dependencies) # save template in database template_version_manager_api.insert(template_version_manager, template) except exceptions.NotUniqueError: return HttpResponseBadRequest( "A template with the same name already exists. Please choose another name." ) except Exception, e: return _error_response(e.message)
def insert_templates(self): saved_templates = [] saved_template_version = [] list_templates = OaiPmhMock.mock_template() for template in list_templates: # Create template version manager template_version_manager = TemplateVersionManager( title='default_chemical_element_type') template_version_manager_api.insert(template_version_manager, template) saved_template_version.append(template_version_manager) saved_templates.append(template.save()) self.templates = saved_templates self.template_version = saved_template_version
def test_create_version_manager_raises_exception_if_error_in_create_version_manager(self, mock_save_template, mock_save_version_manager, mock_delete_template): # Arrange template_filename = "Schema" template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>" template = _create_template(template_filename, template_content) mock_save_template.return_value = template version_manager = _create_template_version_manager(title="Schema") mock_save_version_manager.side_effect = django_exceptions.ValidationError("") mock_delete_template.return_value = None # Act + Assert with self.assertRaises(ModelError): version_manager_api.insert(version_manager, template)
def test_insert_manager_raises_api_error_if_title_already_exists(self, mock_version_manager_save, mock_template_save, mock_template_delete): # Arrange template_filename = "schema.xsd" template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>" template = _create_template(template_filename, template_content) mock_template_save.return_value = template mock_template_delete.return_value = None mock_version_manager = _create_template_version_manager(title="Schema") mock_version_manager_save.side_effect = mongoengine_errors.NotUniqueError("") # Act + Assert with self.assertRaises(NotUniqueError): version_manager_api.insert(mock_version_manager, template)
def test_insert_raises_exception_if_error_in_create_template( self, mock_save_template): # Arrange mock_user = create_mock_user("1", is_superuser=True) mock_request = create_mock_request(mock_user) template_filename = "schema.xsd" template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>" template = _create_template(template_filename, template_content) mock_save_template.side_effect = django_exceptions.ValidationError("") mock_version_manager = _create_mock_template_version_manager() # Act + Assert with self.assertRaises(django_exceptions.ValidationError): version_manager_api.insert(mock_version_manager, template, request=mock_request)
def _save_template_version(request, assets, context, template_version_manager): """Save a template version. Args: request: assets: context: template_version_manager: Returns: """ try: # get the file from the form xsd_file = request.FILES["xsd_file"] # read the content of the file xsd_data = read_xsd_file(xsd_file) template = Template(filename=xsd_file.name, content=xsd_data) template_version_manager_api.insert(template_version_manager, template, request=request) # create the fragment url with all the version of the template (minus the new template) version_manager_string = "" for version in template_version_manager.versions: if version != str(template.id): current_version_string = (version if version_manager_string == "" else f",{version}") version_manager_string += current_version_string # add the fragment data to the url fragment = f"#from={version_manager_string}&to={template.id}" return HttpResponseRedirect( reverse("admin:core_main_app_data_migration") + fragment) except exceptions.XSDError as xsd_error: return handle_xsd_errors(request, assets, context, xsd_error, xsd_data, xsd_file.name) except Exception as e: context["errors"] = html_escape(str(e)) return _upload_template_response(request, assets, context)
def resolve_dependencies(request): """Resolve import/includes to avoid local references. Args: request: Returns: """ try: # Get the parameters name = request.POST.get("name", None) version_manager_id = request.POST.get("version_manager_id", "") filename = request.POST["filename"] xsd_content = request.POST["xsd_content"] schema_locations = request.POST.getlist("schemaLocations[]") dependencies = request.POST.getlist("dependencies[]") # create new object template = Template( filename=filename, content=_get_xsd_content_from_html(xsd_content) ) init_template_with_dependencies( template, _get_dependencies_dict(schema_locations, dependencies), request=request, ) # get the version manager or create a new one if version_manager_id != "": template_version_manager = version_manager_api.get( version_manager_id, request=request ) else: template_version_manager = TemplateVersionManager(title=name) template_version_manager_api.insert( template_version_manager, template, request=request ) except Exception as e: return HttpResponseBadRequest(escape(str(e))) return HttpResponse(json.dumps({}), content_type="application/javascript")
def create(self, validated_data): """ Create and return a new `Template` instance, given the validated data. """ template_object = Template(filename=validated_data['filename'], content=validated_data['content']) template_version_manager_object = validated_data[ 'template_version_manager'] # load dependencies dependencies_dict = load_dependencies(validated_data) # Update the content of the template with dependencies init_template_with_dependencies(template_object, dependencies_dict) # Create the template and its template version manager template_version_manager_api.insert(template_version_manager_object, template_object) return template_object
def _set_xsd_template(xsd_filename, xsd_data): """Register XSD template to Django. Args: xsd_filename: xsd_data: Returns: """ try: template = Template(filename=xsd_filename, content=xsd_data) template_version_manager = TemplateVersionManager(title=xsd_filename) template_version_manager_api.insert(template_version_manager, template) logger.info("XSD template:" + xsd_filename + " registered as a template.") except exceptions.CoreError as e: logger.info(xsd_filename + " didn't registered as a template :" + str(e)) except exceptions.NotUniqueError as e: logger.info(xsd_filename + " didn't registered as a template :" + str(e)) except Exception as e: logger.info(xsd_filename + " didn't registered as a template :" + str(e))
def test_insert_returns_template_version(self, mock_save_template_version_manager, mock_save_template, mock_insert): # Arrange template_filename = "Schema" template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>" template = _create_template(template_filename, template_content) mock_save_template.return_value = template version_manager = _create_template_version_manager() mock_save_template_version_manager.return_value = version_manager mock_insert.return_value = version_manager # Act result = version_manager_api.insert(version_manager, template) # Assert self.assertIsInstance(result, TemplateVersionManager)
def test_create_version_manager_returns_version_manager( self, mock_save_template, mock_save_template_version_manager): # Arrange mock_user = create_mock_user("1", is_superuser=True) mock_request = create_mock_request(mock_user) template_filename = "schema.xsd" template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>" template = _create_template(template_filename, template_content) mock_save_template.return_value = template version_manager = _create_template_version_manager(title="Schema") mock_save_template_version_manager.return_value = version_manager # Act result = version_manager_api.insert(version_manager, template, request=mock_request) # Assert self.assertIsInstance(result, TemplateVersionManager)
def save_template(request): """Save the current template in the database. Args: request: Returns: """ try: template_name = request.POST["templateName"] xsd_string = request.session["newXmlTemplateCompose"] response_dict = {} try: # Build XSD tree xsd_tree = XSDTree.build_tree(xsd_string) # validate the schema error = main_xml_utils.validate_xml_schema(xsd_tree, request=request) if error is not None: return _error_response("This is not a valid XML schema. " + error) except Exception as e: return _error_response("This is not a valid XML schema. " + escape(str(e))) # get list of dependencies dependencies = _get_dependencies_ids( request.session["includedTypesCompose"], request=request) try: # create template version manager template_version_manager = TemplateVersionManager( title=template_name, user=str(request.user.id)) # create template template = Template( filename=template_name, content=xsd_string, dependencies=dependencies, user=str(request.user.id), ) # save template in database template_version_manager_api.insert(template_version_manager, template, request=request) except exceptions.NotUniqueError: return HttpResponseBadRequest( "A template with the same name already exists. Please choose another name." ) except Exception as e: return _error_response(escape(str(e))) return HttpResponse(json.dumps(response_dict), content_type="application/javascript") except Exception as e: return HttpResponseBadRequest(escape(str(e)), content_type="application/javascript")
def test_insert_global_template_as_staff_saves(self): mock_request = create_mock_request(user=self.staff_user1) template_vm_api.insert(self.fixture.global_tvm, self.fixture.global_template, request=mock_request)
def test_insert_own_template_as_superuser_saves(self): mock_request = create_mock_request(user=self.superuser1) template_vm_api.insert(self.fixture.user1_tvm, self.fixture.user1_template, request=mock_request)