def create(self, validated_data): """ Create and return a new `Data` instance, given the validated data. """ # Create data instance = Data( template=validated_data["template"], workspace=validated_data["workspace"] if "workspace" in validated_data else None, title=validated_data["title"], user_id=str(self.context["request"].user.id), ) # Get template template_api.get(instance.template.id, request=self.context["request"]) # Set xml content instance.xml_content = validated_data["xml_content"] # Save the data and retrieve the inserted object inserted_data = data_api.upsert(instance, self.context["request"]) # Encode the response body inserted_data.xml_content = inserted_data.xml_content.encode("utf-8") return inserted_data
def test_template_get_raises_exception_if_object_does_not_exist(self, mock_get_by_id): # Arrange mock_absent_id = ObjectId() mock_get_by_id.side_effect = mongoengine_errors.DoesNotExist # Act + Assert with self.assertRaises(mongoengine_errors.DoesNotExist): template_api.get(mock_absent_id)
def test_get_any_template_as_superuser_returns_template(self): mock_request = create_mock_request(user=self.superuser1) template = template_api.get(self.fixture.user1_template.id, request=mock_request) self.assertEqual(template, self.fixture.user1_template) template = template_api.get(self.fixture.user2_template.id, request=mock_request) self.assertEqual(template, self.fixture.user2_template) template = template_api.get(self.fixture.global_template.id, request=mock_request) self.assertEqual(template, self.fixture.global_template)
def _save_template_xslt(self, request): """Save a template xslt rendering. Args: request: Request. """ try: # Get the list xslt instance try: list_xslt = xslt_transformation_api.get_by_id(request.POST.get('list_xslt')) except (Exception, exceptions.DoesNotExist): list_xslt = None # Get the detail xslt instance try: detail_xslt = xslt_transformation_api.get_by_id(request.POST.get('detail_xslt')) except (Exception, exceptions.DoesNotExist): detail_xslt = None template_xsl_rendering_api.add_or_delete(template_xsl_rendering_id=request.POST.get('id'), template_id=request.POST.get('template'), list_xslt=list_xslt, detail_xslt=detail_xslt) template = template_api.get(request.POST.get('template')) # Get template information (version) version_manager = version_manager_api.get_from_version(template) return HttpResponseRedirect(reverse(self.save_redirect, args=[version_manager.id])) except Exception, e: self.context.update({'errors': html_escape(e.message)}) return self.rendering(request, self.template_name, context=self.context)
def get_xsd(request, title, version_number): """ Page that allows to retrieve an XML Schema by its title and version number. Args: request: Request. title: Schema title. version_number: Version of the schema. Returns: Flatten Schema. """ try: template_version = version_manager_api.get_active_global_version_manager_by_title( title) template = template_api.get( version_manager_api.get_version_by_number(template_version, int(version_number))) flatten = XSDFlattenerDatabaseOrURL(template.content.encode('utf-8')) content_encoded = flatten.get_flat() file_obj = StringIO(content_encoded) return HttpResponse(file_obj, content_type='text/xml') except (exceptions.DoesNotExist, exceptions.ModelError, Exception): return HttpResponseBadRequest( 'Impossible to retrieve the schema with the given name and version.' )
def get_xsd(request, title, version_number): """Page that allows to retrieve an XML Schema by its title and version number. Args: request: Request. title: Schema title. version_number: Version of the schema. Returns: Flatten Schema. """ try: template_version = ( version_manager_api.get_active_global_version_manager_by_title( title, request=request)) template = template_api.get( version_manager_api.get_version_by_number(template_version, int(version_number), request=request), request=request, ) content_encoded = XSDFlattenerDatabaseOrURL( template.content, request=request).get_flat() file_obj = StringIO(content_encoded) return HttpResponse(file_obj, content_type="text/xml") except Exception as e: return HttpResponseBadRequest( "Impossible to retrieve the schema with the given name and " "version: %s" % escape(str(e)))
def oxygen_viewer(request, pk): """ Args: request: pk: Returns: """ template = template_api.get(pk) file_name_html = template.filename.replace('.xsd', '.html') # find a file under static url_file = finders.find( join('core_schema_viewer_app', 'common', 'oxygen', file_name_html)) if url_file: # render a file under templates return django_render( request, "core_schema_viewer_app/common/oxygen/" + file_name_html) else: message = "The oxygen documentation file associated to the request template is not available. " \ "Please contact your administrator for further information." messages.add_message(request, messages.WARNING, message) return redirect(reverse("core_schema_viewer_index"))
def clear_fields(request): """Clear fields of the current form. Args: request: Returns: """ try: # get curate data structure curate_data_structure_id = request.POST["id"] curate_data_structure = curate_data_structure_api.get_by_id( curate_data_structure_id, request.user) # generate form template = template_api.get(str(curate_data_structure.template.id), request=request) root_element = generate_form(template.content, data_structure=curate_data_structure, request=request) # save the root element in the data structure curate_data_structure_api.update_data_structure_root( curate_data_structure, root_element, request.user) # renders the form xsd_form = render_form(request, root_element) return HttpResponse(json.dumps({"xsdForm": xsd_form}), content_type="application/javascript") except Exception as e: return HttpResponseBadRequest(escape(str(e)))
def _fields_to_query(form_values, template_id, get_dot_notation_to_element_func, use_wildcard): """Takes values from the html tree and creates a query from them Args: form_values: template_id: use_wildcard: get_dot_notation_to_element_func: Returns: """ # get template template = template_api.get(template_id) # get namespaces namespaces = get_namespaces(template.content) # get default prefix default_prefix = get_default_prefix(namespaces) query = dict() for field in form_values: bool_comp = field['operator'] is_not = bool_comp == 'NOT' element_type = field.get('type', None) # get element value value = get_element_value(field) # get comparison operator comparison = get_element_comparison(field) element_id = field['id'] if element_type == "query": try: saved_query = saved_query_api.get_by_id(element_id) except DoesNotExist: raise MongoQueryException( "The saved query does not exist anymore.") criteria = build_query_criteria(json.loads(saved_query.query), is_not) else: data_structure_element = data_structure_element_api.get_by_id( element_id) element = get_dot_notation_to_element_func(data_structure_element, namespaces) criteria = build_criteria(element, comparison, value, element_type, default_prefix, is_not, use_wildcard) if bool_comp == 'OR': query = build_or_criteria(query, criteria) elif bool_comp == 'AND': query = build_and_criteria(query, criteria) else: if form_values.index(field) == 0: query.update(criteria) else: query = build_and_criteria(query, criteria) return query
def get_dependency_content(self, uri): """ Get the content of the dependency from the database or from the URL. Try to get the content from the database first and then try to download it from the provided URI. Args: uri: Content URI. Returns: Content. """ # parse url url = urlparse(uri) # get pattern to match a template download url pattern = get_template_download_pattern() # match url match = pattern.match(url.path) # if match if match: try: # get pk from match object_id = match.group('pk') # get template object using pk template = template_api.get(object_id) # get template content content = template.content except (exceptions.DoesNotExist, exceptions.ModelError, Exception): content = super(XSDFlattenerDatabaseOrURL, self).get_dependency_content(uri) else: content = super(XSDFlattenerDatabaseOrURL, self).get_dependency_content(uri) return content
def _associated_templates_post(request): """ associated templates modal POST Args: request: Returns: """ try: form = AssociatedTemplatesForm(request.POST) if form.is_valid(): templates = request.POST.getlist('templates_manager', []) exporter_id = request.POST.get('id', None) if exporter_id is not None: exporter = exporter_api.get_by_id(exporter_id) template_id_list = [ template_api.get(template_id) for template_id in templates ] exporter.templates = template_id_list exporter_api.upsert(exporter) return HttpResponse(json.dumps({}), content_type='application/javascript') else: return HttpResponseBadRequest( 'Bad entries. Please check your entries') except Exception, e: return HttpResponseBadRequest(e.message, content_type='application/javascript')
def _save_custom_resources(self, request, template_id): """Saves an XSLT. Args: request: Request. template_id """ try: # get the template template = template_api.get(template_id, request=request) # get the file from the form upload_file = request.FILES["json_file"].read().decode("utf-8") data = json.loads(upload_file) custom_resource_api.replace_custom_resources_by_template( template, data) return HttpResponseRedirect( reverse("admin:core_main_registry_app_custom_registry")) except Exception as e: self.context.update({"errors": html_escape(str(e))}) return admin_render(request, self.template_name, context=self.context)
def update_user_input(request): """Updates the user input of the query builder according to the type of the selected element Args: request: Returns: """ from_element_id = request.POST['elementID'] template_id = request.POST['templateID'] # get schema element data_structure_element = data_structure_element_api.get_by_id( from_element_id) # get template template = template_api.get(template_id) # convert xml path to mongo dot notation namespaces = get_namespaces(template.content) default_prefix = get_default_prefix(namespaces) element_type = data_structure_element.options['type'] user_inputs = get_user_inputs(element_type, data_structure_element, default_prefix) response_dict = {'userInputs': user_inputs, 'element_type': element_type} return HttpResponse(json.dumps(response_dict), content_type='application/javascript')
def generate_choice(request, explore_data_structure_id): """Generate a choice branch absent from the form. Args: request: explore_data_structure_id: Returns: """ try: element_id = request.POST["id"] explore_data_structure = explore_data_structure_api.get_by_id( explore_data_structure_id) template = template_api.get(str(explore_data_structure.template.id), request=request) xsd_parser = get_parser(request=request) html_form = xsd_parser.generate_choice_absent( element_id, template.content, data_structure=explore_data_structure, renderer_class=CustomCheckboxRenderer, ) except Exception as e: return HttpResponseBadRequest( "An unexpected error occurred: %s" % escape(str(e)), content_type="application/javascript", ) return HttpResponse(html_form)
def _associated_templates_post(request): """associated templates modal POST Args: request: Returns: """ form = AssociatedTemplatesForm(request.POST, request=request) if form.is_valid(): templates = request.POST.getlist("templates_manager", []) exporter_id = request.POST.get("id", None) if exporter_id is not None: exporter = exporter_api.get_by_id(exporter_id) template_id_list = [ template_api.get(template_id, request=request) for template_id in templates ] exporter.templates = template_id_list exporter_api.upsert(exporter) return HttpResponse(json.dumps({}), content_type="application/javascript") else: return HttpResponseBadRequest("Bad entries. Please check your entries")
def check_query_form(form_values, template_id, request=None): """Checks that values entered by the user match each element type Args: form_values: template_id: request: Returns: """ template = template_api.get(template_id, request=request) namespaces = get_namespaces(template.content) default_prefix = get_default_prefix(namespaces) # check if there are no errors in the query errors = [] if len(form_values) == 0: errors.append("The query is empty.") for field in form_values: element_value = get_element_value(field) element_name = field.get("name", "Unnamed field") element_type = field.get("type", None) # If there is a type to check if element_type: error = validate_element_value( element_name, element_type, element_value, default_prefix ) if error is not None: errors.append(error) return errors
def get(self, request, *args, **kwargs): """ GET request. Create/Show the form for the configuration. Args: request: *args: **kwargs: Returns: """ template_id = kwargs.pop('template_id') # Get the template template = template_api.get(template_id) # Get template information (version) version_manager = version_manager_api.get_from_version(template) version_number = version_manager_api.get_version_number( version_manager, template_id) try: # Get the existing configuration to build the form template_xsl_rendering = template_xsl_rendering_api.get_by_template_id( template_id) data = { 'id': template_xsl_rendering.id, 'template': template.id, 'list_xslt': template_xsl_rendering.list_xslt.id if template_xsl_rendering.list_xslt else None, 'detail_xslt': template_xsl_rendering.detail_xslt.id if template_xsl_rendering.detail_xslt else None } except (Exception, exceptions.DoesNotExist): # If no configuration, new form with pre-selected fields. data = { 'template': template.id, 'list_xslt': None, 'detail_xslt': None } self.context = { 'template_title': version_manager.title, 'template_version': version_number, "form_template_xsl_rendering": self.form_class(data), 'url_back_to': reverse(self.back_to_url, kwargs={'version_manager_id': version_manager.id}) } return self.rendering(request, self.template_name, context=self.context, assets=self.assets)
def save_data(request): """Save data - delete curate data structure. Args: request: Returns: """ try: # get curate data structure curate_data_structure_id = request.POST["id"] curate_data_structure = curate_data_structure_api.get_by_id( curate_data_structure_id, request.user) # unlock from database if curate_data_structure.data is not None: lock_api.remove_lock_on_object(curate_data_structure.data, request.user) # generate the XML xml_data = render_xml( request, curate_data_structure.data_structure_element_root) if curate_data_structure.data is not None: # update existing data data = curate_data_structure.data else: # create new data data = Data() data.title = curate_data_structure.name template = template_api.get(str(curate_data_structure.template.id), request=request) data.template = template data.user_id = str(request.user.id) # set content data.xml_content = xml_data # save data data = data_api.upsert(data, request) curate_data_structure_api.delete(curate_data_structure, request.user) messages.add_message( request, messages.SUCCESS, get_data_label().capitalize() + " saved with success.", ) except Exception as e: return HttpResponseBadRequest(str(e).replace('"', "'"), content_type="application/javascript") return HttpResponse(json.dumps({"data_id": str(data.id)}), content_type="application/javascript")
def init_refinement_task(template_id): """Asynchronous tasks init refinement Args: template_id: Returns: """ template = template_api.get(template_id) init_refinements(template)
def add_template_metadata_format(metadata_prefix, template_id, request): """Add a new template metadata format. Args: metadata_prefix: Metadata Prefix. template_id: Id of the template. request: Returns: Response. """ try: template = template_api.get(template_id, request=request) version_manager = version_manager_api.get_from_version(template, request=request) xml_schema = template.content target_namespace = _get_target_namespace(xml_schema) version_number = version_manager_api.get_version_number( version_manager, template_id, request=request) schema_url = _get_simple_template_metadata_format_schema_url( version_manager.title, version_number) obj = OaiProviderMetadataFormat( metadata_prefix=metadata_prefix, schema=schema_url, xml_schema=xml_schema, is_default=False, is_template=True, metadata_namespace=target_namespace, template=template, ) upsert(obj, request=request) content = OaiPmhMessage.get_message_labelled( "Metadata format added with success.") return Response(content, status=status.HTTP_201_CREATED) except oai_pmh_exceptions.OAIAPILabelledException as e: raise e except DoesNotExist: raise oai_pmh_exceptions.OAIAPILabelledException( message="Unable to add the new metadata format. " "Impossible to retrieve the template with the " "given template", status_code=status.HTTP_404_NOT_FOUND, ) except exceptions.XMLError as e: raise oai_pmh_exceptions.OAIAPILabelledException( message="Unable to add the new metadata format.%s" % str(e), status_code=status.HTTP_400_BAD_REQUEST, ) except Exception as e: raise oai_pmh_exceptions.OAIAPILabelledException( message="Unable to add the new metadata format.%s" % str(e), status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, )
def get_object(self, pk): """ Get template from db Args: pk: Returns: """ try: return template_api.get(pk) except exceptions.DoesNotExist: raise Http404
def _get_current_template(request): """Get the current template. Args: request: Returns: """ current_template_version = ( version_manager_api.get_active_global_version_manager_by_title( REGISTRY_XSD_FILENAME, request=request)) current_template = template_api.get(current_template_version.current, request=request) return current_template
def test_template_get_returns_template(self, mock_get_by_id): # Arrange mock_template_filename = "Schema" mock_template_content = "<schema xmlns='http://www.w3.org/2001/XMLSchema'></schema>" mock_template = _create_mock_template(mock_template_filename, mock_template_content) mock_get_by_id.return_value = mock_template # Act result = template_api.get(mock_template.id) # Assert self.assertIsInstance(result, Template)
def get_current_registry_template(): """ Get the current template used for the registry. Returns: Template: """ try: template_version = version_manager_api.\ get_active_global_version_manager_by_title(REGISTRY_XSD_FILENAME) return template_api.get( version_manager_api.get_current(template_version)) except Exception, e: raise exceptions.ModelError(e.message)
def insert_sub_elements_query(request): """Inserts a query for a sub element in the query builder Args: request: Returns: """ form_values = json.loads(request.POST["formValues"]) template_id = request.POST["templateID"] criteria_id = request.POST["criteriaID"] # get template template = template_api.get(template_id, request=request) # get template namespaces namespaces = get_namespaces(template.content) # get default prefix default_prefix = get_default_prefix(namespaces) # keep only selected fields form_values = [field for field in form_values if field["selected"] is True] errors = check_query_form(form_values, template_id, request=request) if len(errors) == 0: query = sub_elements_to_query(form_values, namespaces, default_prefix, request) displayed_query = sub_elements_to_pretty_query(form_values, namespaces, request) ui_id = "ui" + criteria_id[4:] temporary_query = SavedQuery( user_id=ExploreExampleAppConfig.name, template=template, query=json.dumps(query), displayed_query=displayed_query, ) saved_query_api.upsert(temporary_query) response_dict = { "criteriaID": criteria_id, "prettyQuery": displayed_query, "uiID": ui_id, "queryID": str(temporary_query.id), } else: return HttpResponseBadRequest("<br/>".join(errors), content_type="application/javascript") return HttpResponse(json.dumps(response_dict), content_type="application/javascript")
def _get_current_template(): """Get the current template. Returns: """ current_template_version = ( version_manager_api.get_active_global_version_manager_by_title( REGISTRY_XSD_FILENAME ) ) current_template = template_api.get( version_manager_api.get_current(current_template_version) ) return current_template
def disable_template_version_from_version_manager(request): """ Disable a template version of a version manager. Args: request: Returns: """ try: disable_version_of_version_manager(template_api.get(request.GET['id'])) except Exception, e: return HttpResponseBadRequest(e.message, content_type='application/javascript')
def _save_template_xslt(self, request): """Save a template xslt rendering. Args: request: Request. """ try: # Get the list xslt instance try: list_xslt = xslt_transformation_api.get_by_id( request.POST.get("list_xslt")) except (Exception, exceptions.DoesNotExist): list_xslt = None # Get the list detail xslt instance try: list_detail_xslt = xslt_transformation_api.get_by_id_list( request.POST.getlist("list_detail_xslt")) except (Exception, exceptions.DoesNotExist): list_detail_xslt = None # Get the default detail xslt instance try: default_detail_xslt = xslt_transformation_api.get_by_id( request.POST.get("default_detail_xslt")) except (Exception, exceptions.DoesNotExist): default_detail_xslt = None template_xsl_rendering_api.add_or_delete( template_xsl_rendering_id=request.POST.get("id"), template_id=request.POST.get("template"), list_xslt=list_xslt, default_detail_xslt=default_detail_xslt, list_detail_xslt=list_detail_xslt, ) template = template_api.get(request.POST.get("template"), request=request) # Get template information (version) version_manager = version_manager_api.get_from_version( template, request=request) return HttpResponseRedirect( reverse(self.save_redirect, args=[version_manager.id])) except Exception as e: self.context.update({"errors": html_escape(str(e))}) return self.rendering(request, self.template_name, context=self.context)
def get_sub_elements_query_builder(request): """Build the form for queries on sub elements Args: request: Returns: """ leaves_id = request.POST["leavesID"] template_id = request.POST["templateID"] # get list of ids from string list_leaves_id = leaves_id.split(" ") # get template template = template_api.get(template_id, request=request) # get template namespaces namespaces = get_namespaces(template.content) # get default prefix default_prefix = get_default_prefix(namespaces) # get the parent name using the first schema element of the list parent_name = get_parent_name(list_leaves_id[0], namespaces, request) form_fields = [] for leaf_id in list_leaves_id: data_structure_element = data_structure_element_api.get_by_id( leaf_id, request) element_type = data_structure_element.options["type"] element_name = data_structure_element.options["name"] user_inputs = get_user_inputs(element_type, data_structure_element, default_prefix) form_fields.append({ "element_id": leaf_id, "element_name": element_name, "element_type": element_type, "html": user_inputs, }) response_dict = { "subElementQueryBuilder": render_sub_elements_query(parent_name, form_fields) } return HttpResponse(json.dumps(response_dict), content_type="application/javascript")
def set_current_template_version_from_version_manager(request): """ Set the current version of a template. Args: request: Returns: """ try: set_current_version_from_version_manager( template_api.get(request.GET['id'])) except Exception, e: return HttpResponseBadRequest(e.message, content_type='application/javascript')