class StartCurate(View): """Start Curate Ajax""" @method_decorator( decorators.permission_required( content_type=rights.curate_content_type, permission=rights.curate_access, raise_exception=True, ) ) def get(self, request): """Load forms to start curating. Args: request: Returns: """ return curate_ajax.start_curate(request) @method_decorator( decorators.permission_required( content_type=rights.curate_content_type, permission=rights.curate_access, raise_exception=True, ) ) def post(self, request): """Load forms to start curating. Add role to response url. Args: request: Returns: """ response = curate_ajax.start_curate(request) if response.status_code == 200: role = request.GET.get("role", None) response.content = "{0}?role={1}".format( response.content.decode("utf-8"), role ) return response
class StartCurate(View): """Start curate.""" def __init__(self): super(StartCurate, self).__init__() self.assets = { "js": [ { "path": "core_curate_app/user/js/select_template.js", "is_raw": False }, { "path": "core_curate_registry_app/user/js/start_curate.js", "is_raw": False, }, ], "css": ["core_curate_app/user/css/style.css"], } self.modals = [] @method_decorator( decorators.permission_required( content_type=rights.curate_content_type, permission=rights.curate_access, login_url=reverse_lazy("core_main_app_login"), )) def get(self, request, role): """Start curate with role parameter. Args: request: role: Returns: """ try: # Get custom resources for the current template custom_resource = custom_resource_api.get_by_current_template_and_slug( role, request=request) except exceptions.DoesNotExist: custom_resource = None context = { "template_id": version_manager_api.get_active_global_version_manager_by_title( REGISTRY_XSD_FILENAME, request=request).current, "role": role, "custom_resource": custom_resource, } return render( request, "core_curate_app/user/curate.html", assets=self.assets, modals=self.modals, context=context, )
class SaveQueryView(View): fields_to_query_func = None @method_decorator( decorators.permission_required( content_type=rights.explore_example_content_type, permission=rights.explore_example_save_query, raise_exception=True, )) def post(self, request): """Save a query and update the html display Args: request: Returns: """ form_values = json.loads(request.POST["formValues"]) template_id = request.POST["templateID"] # Check that the user can save a query if "_auth_user_id" not in request.session: error = "You have to login to save a query." return HttpResponseBadRequest( error, content_type="application/javascript") # Check that the query is valid errors = check_query_form(form_values, template_id, request=request) if len(errors) == 0: try: query = self.fields_to_query_func(form_values, template_id, request=request) displayed_query = fields_to_pretty_query(form_values) # save the query in the data base saved_query = SavedQuery( user_id=str(request.user.id), template=template_api.get(template_id, request=request), query=json.dumps(query), displayed_query=displayed_query, ) saved_query_api.upsert(saved_query) except MongoQueryException as e: errors = [str(e)] return HttpResponseBadRequest( _render_errors(errors), content_type="application/javascript") else: return HttpResponseBadRequest( _render_errors(errors), content_type="application/javascript") return HttpResponse(json.dumps({}), content_type="application/javascript")
class GetQueryView(View): fields_to_query_func = None @method_decorator( decorators.permission_required( content_type=rights.explore_example_content_type, permission=rights.explore_example_access, raise_exception=True)) def post(self, request): """Get a query Args: request: Returns: """ try: template_id = request.POST['templateID'] query_id = request.POST['queryID'] form_values = json.loads(request.POST['formValues']) # save current query builder in session to restore it when coming back to the page query_form = request.POST['queryForm'] request.session['savedQueryFormExplore'] = query_form errors = check_query_form(form_values, template_id) query_object = query_api.get_by_id(query_id) if len(query_object.data_sources) == 0: errors.append("Please select at least 1 data source.") if len(errors) == 0: query_content = self.fields_to_query_func( form_values, template_id) query_object.content = json.dumps(query_content) query_api.upsert(query_object) else: return HttpResponseBadRequest( _render_errors(errors), content_type='application/javascript') return HttpResponse(json.dumps({}), content_type='application/javascript') except exceptions.ModelError: return HttpResponseBadRequest( 'Invalid input.', content_type='application/javascript') except Exception: return HttpResponseBadRequest( 'An unexpected error occurred.', content_type='application/javascript')
class ResultQueryExampleRedirectView(ResultQueryRedirectView): model_name = PersistentQueryExample.__name__ object_name = "persistent_query_example" redirect_url = "core_explore_example_results" @method_decorator( decorators.permission_required( content_type=rights.explore_example_content_type, permission=rights.explore_example_access, login_url=reverse_lazy("core_main_app_login"), )) def get(self, request, *args, **kwargs): return super(ResultQueryExampleRedirectView, self).get(self, request, *args, **kwargs) @staticmethod def _get_persistent_query_by_id(persistent_query_id, user): return persistent_query_example_api.get_by_id(persistent_query_id, user) @staticmethod def _get_persistent_query_by_name(persistent_query_name, user): return persistent_query_example_api.get_by_name( persistent_query_name, user) @staticmethod def get_url_path(): return reverse( ResultQueryExampleRedirectView.redirect_url, kwargs={ "template_id": "template_id", "query_id": "query_id" }, ).split("results")[0] @staticmethod def _get_reversed_url(query): return reverse( ResultQueryExampleRedirectView.redirect_url, kwargs={ "template_id": query.templates[0].id, "query_id": query.id }, ) @staticmethod def _get_reversed_url_if_failed(): return reverse("core_explore_example_index")
class SuggestionsKeywordSearchView(View): @method_decorator( decorators.permission_required( content_type=rights.explore_keyword_content_type, permission=rights.explore_keyword_access, login_url=reverse_lazy("core_main_app_login"))) def post(self, request, *args, **kwargs): """ POST Args: request: *args: **kwargs: Returns: """ suggestions = [] search_form = KeywordForm(data=request.POST) keywords = request.POST.get('term') if search_form.is_valid(): try: # get form values query_id = search_form.cleaned_data.get('query_id', None) global_templates = search_form.cleaned_data.get( 'global_templates', []) user_templates = search_form.cleaned_data.get( 'user_templates', []) # get all template version manager ids template_version_manager_ids = global_templates + user_templates # from ids, get all version manager version_manager_list = version_manager_api.get_by_id_list( template_version_manager_ids) # from all version manager, build a list of all version (template) template_ids = [] map(lambda x: template_ids.extend(x.versions), version_manager_list) if query_id is not None and keywords is not None: # get query query = query_api.get_by_id(query_id) # Check the selected data sources if check_data_source(query): # Prepare query query = self._get_query_prepared( keywords, query, request, template_ids) # Send query dict_results = send(request, query, len(query.data_sources) - 1, 1) if dict_results['count'] > 0: self._extract_suggestion_from_results( dict_results, keywords, suggestions) except Exception, e: logger.error("Exception while generating suggestions: " + e.message) return HttpResponse(json.dumps({'suggestions': suggestions}), content_type='application/javascript')
class GetQueryView(View): fields_to_query_func = None @method_decorator( decorators.permission_required( content_type=rights.explore_example_content_type, permission=rights.explore_example_access, raise_exception=True, )) def post(self, request): """Get a query Args: request: Returns: """ try: template_id = request.POST["templateID"] query_id = request.POST["queryID"] form_values = (json.loads(request.POST["formValues"]) if "formValues" in request.POST else None) order_by_field = request.POST["orderByField"].strip() order_by_field_array = order_by_field.split(";") # save current query builder in session to restore it when coming # back to the page if "queryForm" in request.POST: query_form = request.POST["queryForm"] request.session["savedQueryFormExplore"] = query_form errors = [] query_object = query_api.get_by_id(query_id, request.user) # set the data-sources sorting value according to the POST request field for data_sources_index in range(len(query_object.data_sources)): # updating only the existing data-sources (the new data-source already got # the default filter value) if data_sources_index in range(0, len(order_by_field_array)): query_object.data_sources[ data_sources_index].order_by_field = order_by_field_array[ data_sources_index] if len(query_object.data_sources) == 0: errors.append("Please select at least 1 data source.") if len(errors) == 0 and form_values: errors.append( check_query_form(form_values, template_id, request=request)) query_content = self.fields_to_query_func(form_values, template_id, request=request) query_object.content = json.dumps(query_content) elif len(errors) > 0: return HttpResponseBadRequest( _render_errors(errors), content_type="application/javascript") query_api.upsert(query_object, request.user) return HttpResponse(json.dumps({}), content_type="application/javascript") except exceptions.ModelError: return HttpResponseBadRequest( "Invalid input.", content_type="application/javascript") except Exception as e: return HttpResponseBadRequest( "An unexpected error occurred: %s" % escape(str(e)), content_type="application/javascript", )
class SelectFieldsView(View): build_query_url = 'core_explore_example_build_query' load_form_url = 'core_explore_example_load_form' generate_element_url = 'core_explore_example_generate_element' remove_element_url = 'core_explore_example_remove_element' generate_choice_url = 'core_explore_example_generate_choice' @method_decorator( decorators.permission_required( content_type=rights.explore_example_content_type, permission=rights.explore_example_access, login_url=reverse_lazy("core_main_app_login"))) def get(self, request, template_id, *args, **kwargs): """Loads view to customize exploration tree Args: request: template_id: Returns: """ try: # Set the assets assets = { "js": [ { "path": 'core_main_app/common/js/XMLTree.js', "is_raw": False }, { "path": "core_parser_app/js/autosave.js", "is_raw": False }, { "path": "core_parser_app/js/autosave_checkbox.js", "is_raw": False }, { "path": "core_parser_app/js/autosave.raw.js", "is_raw": True }, { "path": "core_parser_app/js/buttons.js", "is_raw": False }, { "path": "core_explore_example_app/user/js/buttons.raw.js", "is_raw": True }, { "path": "core_parser_app/js/modules.js", "is_raw": False }, { "path": "core_parser_app/js/choice.js", "is_raw": False }, { "path": "core_explore_example_app/user/js/choice.raw.js", "is_raw": True }, { "path": "core_explore_example_app/user/js/select_fields.js", "is_raw": False }, { "path": "core_explore_example_app/user/js/select_fields.raw.js", "is_raw": True }, ], "css": [ 'core_explore_example_app/user/css/xsd_form.css', 'core_explore_example_app/user/css/style.css' ] } template = template_api.get(template_id) # get data structure data_structure = explore_data_structure_api.create_and_get_explore_data_structure( template, request.user.id) root_element = data_structure.data_structure_element_root # renders the form xsd_form = render_form(request, root_element) # Set the context context = { "template_id": template_id, "build_query_url": self.build_query_url, "load_form_url": self.load_form_url, "generate_element_url": self.generate_element_url, "remove_element_url": self.remove_element_url, "generate_choice_url": self.generate_choice_url, "data_structure_id": str(data_structure.id), "xsd_form": xsd_form } return render(request, 'core_explore_example_app/user/select_fields.html', assets=assets, context=context) except Exception, e: return render(request, 'core_explore_example_app/user/errors.html', assets={}, context={'errors': e.message})
class EnterDataView(View): def __init__(self): super(EnterDataView, self).__init__() self.assets = { "js": [ { "path": "core_main_app/common/js/debounce.js", "is_raw": False }, { "path": "core_main_app/common/js/elementViewport.js", "is_raw": False }, { "path": "core_curate_app/user/js/enter_data.js", "is_raw": False }, { "path": "core_curate_app/user/js/enter_data.raw.js", "is_raw": True }, { "path": "core_parser_app/js/modules.js", "is_raw": False }, { "path": "core_parser_app/js/modules.raw.js", "is_raw": True }, { "path": "core_main_app/common/js/XMLTree.js", "is_raw": False }, { "path": "core_parser_app/js/autosave.js", "is_raw": False }, { "path": "core_parser_app/js/autosave.raw.js", "is_raw": True }, { "path": "core_parser_app/js/buttons.js", "is_raw": False }, { "path": "core_curate_app/user/js/buttons.raw.js", "is_raw": True }, { "path": "core_parser_app/js/choice.js", "is_raw": False }, { "path": "core_curate_app/user/js/choice.raw.js", "is_raw": True }, ], "css": [ "core_curate_app/user/css/common.css", "core_curate_app/user/css/xsd_form.css", "core_parser_app/css/use.css", ], } if ENABLE_XML_ENTITIES_TOOLTIPS: self.assets["js"].append({ "path": "core_curate_app/user/js/xml_entities_tooltip.js", "is_raw": False, }) self.modals = [ "core_curate_app/user/data-entry/modals/cancel-changes.html", "core_curate_app/user/data-entry/modals/cancel-form.html", "core_curate_app/user/data-entry/modals/clear-fields.html", "core_curate_app/user/data-entry/modals/download-options.html", "core_curate_app/user/data-entry/modals/save-form.html", "core_curate_app/user/data-entry/modals/use-validation.html", "core_curate_app/user/data-entry/modals/xml-error.html", "core_curate_app/user/data-entry/modals/xml-valid.html", ] def build_context(self, request, curate_data_structure, reload_unsaved_changes): """Build the context of the view Args: request: curate_data_structure: reload_unsaved_changes: Returns: """ # get xsd string from the template template = template_api.get(str(curate_data_structure.template.id), request=request) xsd_string = template.content if reload_unsaved_changes: # get root element from the data structure root_element = curate_data_structure.data_structure_element_root else: # if form string provided, use it to generate the form xml_string = curate_data_structure.form_string # get the root element root_element = generate_form( xsd_string, xml_string, 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 { "edit": True if curate_data_structure.data is not None else False, "xsd_form": xsd_form, "data_structure": curate_data_structure, } @method_decorator( decorators.permission_required( content_type=rights.curate_content_type, permission=rights.curate_access, login_url=reverse_lazy("core_main_app_login"), )) def get(self, request, curate_data_structure_id, reload_unsaved_changes=False): """Load view to enter data. Args: request: curate_data_structure_id: reload_unsaved_changes: Returns: """ curate_data_structure = None try: # Retrieve CurateDataStructure and lock the object for the current # user. curate_data_structure = _get_curate_data_structure_by_id( curate_data_structure_id, request) # Lock from database if curate_data_structure.data is not None: lock_api.set_lock_object(curate_data_structure.data, request.user) # Check if we need to change the user. Code executed only if the # data is unlocked. set_lock_object() raises LockError. if str(request.user.id) != curate_data_structure.user: curate_data_structure.user = str(request.user.id) curate_data_structure = curate_data_structure_api.upsert( curate_data_structure, request.user) return render( request, "core_curate_app/user/data-entry/enter_data.html", assets=self.assets, context=self.build_context(request, curate_data_structure, reload_unsaved_changes), modals=self.modals, ) except (LockError, AccessControlError, ModelError, DoesNotExist) as ex: return render( request, "core_curate_app/user/errors.html", assets={}, context={"errors": str(ex)}, ) except Exception as e: try: # Unlock from database if (curate_data_structure is not None and curate_data_structure.data is not None): lock_api.remove_lock_on_object(curate_data_structure.data, request.user) except Exception as lock_exc: # CurateDataStructure not found, continue search logger.warning( "'EnterDataView.get' threw an exception: {0}".format( str(lock_exc))) return render( request, "core_curate_app/user/errors.html", assets={}, context={"errors": str(e)}, )
class IndexView(View): api = template_version_manager_api get_redirect = 'core_explore_example_app/user/index.html' select_object_redirect = "core_explore_example_select_fields" build_query_redirect = "core_explore_example_build_query" object_name = "template" @method_decorator( decorators.permission_required( content_type=rights.explore_example_content_type, permission=rights.explore_example_access, login_url=reverse_lazy("core_main_app_login"))) def get(self, request, *args, **kwargs): """ Page that allows to select a template to start exploring data Args: request: Returns: """ assets = {"css": ['core_explore_example_app/user/css/style.css']} global_active_template_list = self.get_global_active_list() user_active_template_list = self.get_user_active_list(request.user.id) context = { 'global_objects': global_active_template_list, 'user_objects': user_active_template_list, 'object_name': self.object_name, 'select_object_redirect': self.select_object_redirect, 'build_query_redirect': self.build_query_redirect, } return render(request, self.get_redirect, assets=assets, context=context) def get_global_active_list(self): """ Get all global version managers. Args: Returns: List of all global version managers """ return self.api.get_active_global_version_manager() def get_user_active_list(self, user_id): """ Get all active version managers with given user id. Args: user_id: Returns: List of all global version managers with given user. """ return self.api.get_active_version_manager_by_user_id(user_id)
class BuildQueryView(View): build_query_url = 'core_explore_example_build_query' get_query_url = 'core_explore_example_get_query' save_query_url = 'core_explore_example_save_query' results_url = 'core_explore_example_results' select_fields_url = 'core_explore_example_select_fields' object_name = "template" data_sources_selector_template = 'core_explore_common_app/user/selector/data_sources_selector' \ '.html' query_builder_interface = 'core_explore_example_app/user/query_builder/initial_form.html' @method_decorator( decorators.permission_required( content_type=rights.explore_example_content_type, permission=rights.explore_example_access, login_url=reverse_lazy("core_main_app_login"))) def get(self, request, template_id, query_id=None): """Page that allows to build and submit queries Args: request: template_id: query_id: Returns: """ try: template = template_api.get(template_id) if template is None: return render(request, 'core_explore_example_app/user/errors.html', assets={}, context={ 'errors': "The selected {0} does not exist".format( self.object_name) }) # Init variables saved_query_form = "" try: explore_data_structure = explore_data_structure_api.get_by_user_id_and_template_id( str(request.user.id), template_id) # If custom fields form present, set it custom_form = explore_data_structure.selected_fields_html_tree except exceptions.DoesNotExist: custom_form = None # If new form if query_id is None: # empty session variables request.session['mapCriteriaExplore'] = dict() request.session['savedQueryFormExplore'] = "" # create new query object query = self._create_new_query(request, template) else: # if not a new form and a query form is present in session if 'savedQueryFormExplore' in request.session: saved_query_form = request.session['savedQueryFormExplore'] query = query_api.get_by_id(query_id) # Get saved queries of a user if '_auth_user_id' in request.session: user_id = request.session['_auth_user_id'] user_queries = saved_query_api.get_all_by_user_and_template( user_id=user_id, template_id=template_id) else: user_queries = [] assets = {"js": self._get_js(), "css": self._get_css()} context = { 'queries': user_queries, 'template_id': template_id, 'description': self.get_description(), 'title': self.get_title(), 'custom_form': custom_form, 'query_form': saved_query_form, 'query_id': str(query.id), "build_query_url": self.build_query_url, "results_url": self.results_url, "get_query_url": self.get_query_url, "save_query_url": self.save_query_url, "select_fields_url": self.select_fields_url, "data_sources_selector_template": self.data_sources_selector_template, "query_builder_interface": self.query_builder_interface } modals = [ "core_explore_example_app/user/modals/custom_tree.html", "core_explore_example_app/user/modals/sub_elements_query_builder.html", "core_main_app/common/modals/error_page_modal.html", "core_explore_example_app/user/modals/delete_all_queries.html", "core_explore_example_app/user/modals/delete_query.html" ] return render(request, 'core_explore_example_app/user/build_query.html', assets=assets, context=context, modals=modals) except Exception, e: return render(request, 'core_explore_example_app/user/errors.html', assets={}, context={'errors': e.message})
class EnterDataView(View): def __init__(self): super(EnterDataView, self).__init__() self.assets = { "js": [ { "path": "core_curate_app/user/js/enter_data.js", "is_raw": False }, { "path": "core_curate_app/user/js/enter_data.raw.js", "is_raw": True }, { "path": "core_parser_app/js/modules.js", "is_raw": False }, { "path": "core_parser_app/js/modules.raw.js", "is_raw": True }, { "path": 'core_main_app/common/js/XMLTree.js', "is_raw": False }, { "path": "core_parser_app/js/autosave.js", "is_raw": False }, { "path": "core_parser_app/js/autosave.raw.js", "is_raw": True }, { "path": "core_parser_app/js/buttons.js", "is_raw": False }, { "path": "core_curate_app/user/js/buttons.raw.js", "is_raw": True }, { "path": "core_parser_app/js/choice.js", "is_raw": False }, { "path": "core_curate_app/user/js/choice.raw.js", "is_raw": True }, ], "css": [ 'core_curate_app/user/css/xsd_form.css', 'core_parser_app/css/use.css' ] } self.modals = [ 'core_curate_app/user/data-entry/modals/cancel-changes.html', 'core_curate_app/user/data-entry/modals/cancel-form.html', 'core_curate_app/user/data-entry/modals/clear-fields.html', 'core_curate_app/user/data-entry/modals/download-options.html', 'core_curate_app/user/data-entry/modals/save-form.html', 'core_curate_app/user/data-entry/modals/use-validation.html', 'core_curate_app/user/data-entry/modals/xml-error.html', 'core_curate_app/user/data-entry/modals/xml-valid.html', ] def build_context(self, request, curate_data_structure, reload_unsaved_changes): """ Build the context of the view Args: request: curate_data_structure: reload_unsaved_changes: Returns: """ # get xsd string from the template xsd_string = curate_data_structure.template.content if reload_unsaved_changes: # get root element from the data structure root_element = curate_data_structure.data_structure_element_root else: # if form string provided, use it to generate the form xml_string = curate_data_structure.form_string # get the root element root_element = generate_form(xsd_string, xml_string) # save the root element in the data structure curate_data_structure_api.update_data_structure_root( curate_data_structure, root_element) # renders the form xsd_form = render_form(request, root_element) return { "edit": True if curate_data_structure.data is not None else False, "xsd_form": xsd_form, "data_structure": curate_data_structure, } @method_decorator( decorators.permission_required( content_type=rights.curate_content_type, permission=rights.curate_access, login_url=reverse_lazy("core_main_app_login"))) def get(self, request, curate_data_structure_id, reload_unsaved_changes=False): """Load view to enter data. Args: request: curate_data_structure_id: reload_unsaved_changes: Returns: """ try: # get data structure curate_data_structure = _get_curate_data_structure_by_id( curate_data_structure_id, request) # lock from database if curate_data_structure.data is not None: lock_api.set_lock_object(curate_data_structure.data, request.user) # Check if we need to change the user. # Code executed only if the data is unlocked. set_lock_object() raises LockError. if str(request.user.id) != curate_data_structure.user: curate_data_structure.user = str(request.user.id) curate_data_structure = curate_data_structure_api.upsert( curate_data_structure) # Set the context context = self.build_context(request, curate_data_structure, reload_unsaved_changes) return render(request, 'core_curate_app/user/data-entry/enter_data.html', assets=self.assets, context=context, modals=self.modals) except LockError, ler: return render(request, 'core_curate_app/user/errors.html', assets={}, context={'errors': ler.message}) except Exception, e: try: # unlock from database if curate_data_structure is not None and curate_data_structure.data is not None: lock_api.remove_lock_on_object(curate_data_structure.data, request.user) except: pass return render(request, 'core_curate_app/user/errors.html', assets={}, context={'errors': e.message})
class ResultQueryView(ResultsView): back_to_query_redirect = "core_explore_example_build_query" get_query_url = "core_explore_example_get_query" @method_decorator( decorators.permission_required( content_type=rights.explore_example_content_type, permission=rights.explore_example_access, login_url=reverse_lazy("core_main_app_login"), )) def get(self, request, template_id, query_id): """Query results view Args: request: template_id: query_id: Returns: """ # get query query = query_api.get_by_id(query_id, request.user) context = { "template_id": template_id, "query_id": query_id, "exporter_app": False, "back_to_query_redirect": self.back_to_query_redirect, "get_query_url": self.get_query_url, "default_date_toggle_value": DEFAULT_DATE_TOGGLE_VALUE, "data_sorting_fields": super().build_sorting_context_array(query), "default_data_sorting_fields": ",".join(DATA_SORTING_FIELDS), } if "core_exporters_app" in INSTALLED_APPS: query = query_api.get_by_id(query_id, request.user) context["exporter_app"] = True context["templates_list"] = json.dumps( [str(template.id) for template in query.templates]) return render( request, "core_explore_example_app/user/results.html", assets=self.assets, modals=self.modals, context=context, ) def _load_assets(self): assets = super()._load_assets() extra_assets = { "js": [ { "path": "core_explore_example_app/user/js/refresh_sorting.raw.js", "is_raw": True, }, { "path": "core_explore_example_app/user/js/refresh_sorting.js", "is_raw": False, }, { "path": "core_explore_example_app/user/js/persistent_query.raw.js", "is_raw": True, }, ], "css": [], } assets["js"].extend(extra_assets["js"]) assets["css"].extend(extra_assets["css"]) return assets def _load_modals(self): """Return modals structure Returns: """ return super()._load_modals()
class BuildQueryView(View): build_query_url = "core_explore_example_build_query" get_query_url = "core_explore_example_get_query" save_query_url = "core_explore_example_save_query" results_url = "core_explore_example_results" select_fields_url = "core_explore_example_select_fields" object_name = "template" data_sources_selector_template = ( "core_explore_common_app/user/selector/data_sources_selector" ".html") query_builder_interface = ( "core_explore_example_app/user/query_builder/initial_form.html") @method_decorator( decorators.permission_required( content_type=rights.explore_example_content_type, permission=rights.explore_example_access, login_url=reverse_lazy("core_main_app_login"), )) def get(self, request, template_id, query_id=None): """Page that allows to build and submit queries Args: request: template_id: query_id: Returns: """ try: template = template_api.get(template_id, request=request) if template is None: return render( request, "core_explore_example_app/user/errors.html", assets={}, context={ "errors": "The selected {0} does not exist".format( self.object_name) }, ) # Init variables saved_query_form = "" try: explore_data_structure = ( explore_data_structure_api.get_by_user_id_and_template_id( str(request.user.id), template_id)) # If custom fields form present, set it custom_form = explore_data_structure.selected_fields_html_tree except exceptions.DoesNotExist: custom_form = None # If new form if query_id is None: # empty session variables request.session["mapCriteriaExplore"] = dict() request.session["savedQueryFormExplore"] = "" # create new query object query = self._create_new_query(request, template) else: # if not a new form and a query form is present in session if "savedQueryFormExplore" in request.session: saved_query_form = request.session["savedQueryFormExplore"] query = query_api.get_by_id(query_id, request.user) # Get saved queries of a user if "_auth_user_id" in request.session: user_id = request.session["_auth_user_id"] user_queries = saved_query_api.get_all_by_user_and_template( user_id=user_id, template_id=template_id) else: user_queries = [] assets = {"js": self._get_js(), "css": self._get_css()} context = { "queries": user_queries, "template_id": template_id, "description": self.get_description(), "title": self.get_title(), "data_sorting_fields": build_sorting_context_array(query), "default_data_sorting_fields": ",".join(DATA_SORTING_FIELDS), "custom_form": custom_form, "query_form": saved_query_form, "query_id": str(query.id), "build_query_url": self.build_query_url, "results_url": self.results_url, "get_query_url": self.get_query_url, "save_query_url": self.save_query_url, "select_fields_url": self.select_fields_url, "data_sources_selector_template": self.data_sources_selector_template, "query_builder_interface": self.query_builder_interface, } modals = [ "core_explore_example_app/user/modals/custom_tree.html", "core_explore_example_app/user/modals/sub_elements_query_builder.html", "core_main_app/common/modals/error_page_modal.html", "core_explore_example_app/user/modals/delete_all_queries.html", "core_explore_example_app/user/modals/delete_query.html", ] return render( request, "core_explore_example_app/user/build_query.html", assets=assets, context=context, modals=modals, ) except Exception as e: return render( request, "core_explore_example_app/user/errors.html", assets={}, context={"errors": str(e)}, ) @staticmethod def _create_new_query(request, template): """Create a new query Args: request: template: """ # from the template, we get the version manager template_version_manager = template_version_manager_api.get_by_version_id( str(template.id), request=request) # from the version manager, we get all the version template_ids = template_api.get_all_accessible_by_id_list( template_version_manager.versions, request=request) # create query query = create_default_query(request, template_ids) # then upsert return query_api.upsert(query, request.user) @staticmethod def _get_js(): return [ { "path": "core_explore_example_app/user/js/build_query.js", "is_raw": False, }, { "path": "core_explore_example_app/user/js/build_query.raw.js", "is_raw": True, }, { "path": "core_parser_app/js/autosave.raw.js", "is_raw": True }, { "path": "core_parser_app/js/choice.js", "is_raw": False }, { "path": "core_main_app/common/js/modals/error_page_modal.js", "is_raw": True, }, ] @staticmethod def _get_css(): return [ "core_explore_common_app/user/css/results.css", "core_explore_example_app/user/css/query_builder.css", "core_explore_example_app/user/css/xsd_form.css", ] @staticmethod def get_description(): # FIXME should be in template return ( "Click on a field of the Query Builder to add an element to your query. " "The elements selected in the previous step will appear and you will be " "able to insert them in the query builder. Click on plus/minus icons to " "add/remove criteria. You can save queries to build more complex queries " "and you will retrieve them on your next connection. When your query is " "done, please click on Submit Query to get XML documents that match the " "criteria.") @staticmethod def get_title(): return "Query Builder"
class KeywordSearchView(View): def __init__(self, **kwargs): self.assets = self._load_assets() self.modals = self._load_modals() @method_decorator( decorators.permission_required( content_type=rights.explore_keyword_content_type, permission=rights.explore_keyword_access, login_url=reverse_lazy("core_main_app_login"))) def get(self, request, *args, **kwargs): """ GET Args: request: *args: **kwargs: Returns: """ query_id = str(kwargs['query_id']) if 'query_id' in kwargs else None # assets / modals / forms context = self._get(request, query_id) return render(request, 'core_explore_keyword_app/user/index.html', assets=self.assets, modals=self.modals, context=context) @method_decorator( decorators.permission_required( content_type=rights.explore_keyword_content_type, permission=rights.explore_keyword_access, login_url=reverse_lazy("core_main_app_login"))) def post(self, request, *args, **kwargs): """ POST Args: request: *args: **kwargs: Returns: """ # assets / modals / forms context = self._post(request) return render(request, 'core_explore_keyword_app/user/index.html', assets=self.assets, modals=self.modals, context=context) def _get(self, request, query_id): """ Prepare the GET context Args: user: query_id: Returns: """ error = None display_persistent_query_button = True if query_id is None: # create query query = create_default_query(request, []) # upsert the query query_api.upsert(query) # create keyword form # create all data for select values in forms keywords_data_form = { 'query_id': str(query.id), 'user_id': query.user_id, } else: try: # get the query id query = query_api.get_by_id(query_id) user_id = query.user_id # get all keywords back query_json = json.loads(query.content) keywords = None if '$text' in query_json: keywords = query_json['$text']['$search'].replace( " ", ",").replace('"', '') # get all version managers version_managers = [] for template in query.templates: version_managers.append( str(version_manager_api.get_from_version(template).id)) # create all data for select values in forms keywords_data_form = { 'query_id': str(query.id), 'user_id': user_id, 'keywords': keywords, 'global_templates': version_managers, 'user_templates': version_managers } except Exception, e: error = "An unexpected error occurred while loading the query: {}.".format( e.message) return {'error': error} search_form = KeywordForm(data=keywords_data_form) return _format_keyword_search_context(search_form, error, None, display_persistent_query_button)
class ResultQueryView(View): back_to_query_redirect = 'core_explore_example_build_query' @method_decorator( decorators.permission_required( content_type=rights.explore_example_content_type, permission=rights.explore_example_access, login_url=reverse_lazy("core_main_app_login"))) def get(self, request, template_id, query_id): """Query results view Args: request: template_id: query_id: Returns: """ context = { 'template_id': template_id, 'query_id': query_id, 'exporter_app': False, 'back_to_query_redirect': self.back_to_query_redirect, 'get_shareable_link_url': reverse("core_explore_example_get_persistent_query_url") } assets = { "js": [ { "path": 'core_explore_common_app/user/js/results.js', "is_raw": False }, { "path": 'core_explore_common_app/user/js/results.raw.js', "is_raw": True }, { "path": 'core_main_app/common/js/XMLTree.js', "is_raw": False }, { "path": 'core_main_app/common/js/modals/error_page_modal.js', "is_raw": True }, { "path": 'core_explore_common_app/user/js/button_persistent_query.js', "is_raw": False }, ], "css": [ "core_explore_common_app/user/css/query_result.css", "core_main_app/common/css/XMLTree.css", "core_explore_common_app/user/css/results.css" ], } modals = [ "core_main_app/common/modals/error_page_modal.html", "core_explore_common_app/user/persistent_query/modals/persistent_query_modal.html" ] if 'core_exporters_app' in INSTALLED_APPS: # add all assets needed assets['js'].extend([{ "path": 'core_exporters_app/user/js/exporters/list/modals/list_exporters_selector.js', "is_raw": False }]) # add the modal modals.extend([ "core_exporters_app/user/exporters/list/modals/list_exporters_selector.html" ]) # the modal need all selected template query = query_api.get_by_id(query_id) context['exporter_app'] = True context['templates_list'] = json.dumps( [str(template.id) for template in query.templates]) return render(request, 'core_explore_example_app/user/results.html', assets=assets, modals=modals, context=context)
url(r'^generate-choice/(?P<curate_data_structure_id>\w+)$', user_ajax.generate_choice, name='core_curate_generate_choice'), url(r'^generate-element/(?P<curate_data_structure_id>\w+)$', user_ajax.generate_element, name='core_curate_generate_element'), url(r'^remove-element$', user_ajax.remove_element, name='core_curate_remove_element'), url(r'^clear-fields$', user_ajax.clear_fields, name='core_curate_clear_fields'), url(r'^cancel-changes$', user_ajax.cancel_changes, name='core_curate_cancel_changes'), url(r'^cancel-form$', user_ajax.cancel_form, name='core_curate_cancel_form'), url(r'^save-form$', user_ajax.save_form, name='core_curate_save_form'), url(r'^save-data$', user_ajax.save_data, name='core_curate_save_data'), url(r'^validate-form$', user_ajax.validate_form, name='core_curate_validate_form'), url(r'^view-form/(?P<curate_data_structure_id>\w+)$', permission_required(content_type=rights.curate_content_type, permission=rights.curate_access, login_url=reverse_lazy("core_main_app_login"))( common_views.FormView.as_view()), name='core_curate_view_form') ]
class ViewDataView(View): def __init__(self): super(ViewDataView, self).__init__() self.assets: Dict[str, List[any]] = { "js": [ { "path": "core_curate_app/user/js/view_data.js", "is_raw": False }, { "path": "core_curate_app/user/js/view_data.raw.js", "is_raw": True }, { "path": "core_main_app/common/js/XMLTree.js", "is_raw": False }, ], "css": ["core_main_app/common/css/XMLTree.css"], } self.modals = [ "core_curate_app/user/data-review/modals/save-error.html", ] def build_context(self, request, curate_data_structure): """Build XML string from CurateDataStructure Args: request: curate_data_structure: Returns: """ xml_string = render_xml( request, curate_data_structure.data_structure_element_root) return { "edit": True if curate_data_structure.data is not None else False, "xml_string": xml_string, "data_structure": curate_data_structure, } @method_decorator( decorators.permission_required( content_type=rights.curate_content_type, permission=rights.curate_access, login_url=reverse_lazy("core_main_app_login"), )) def get(self, request, curate_data_structure_id): try: curate_data_structure = _get_curate_data_structure_by_id( curate_data_structure_id, request) if "core_file_preview_app" in INSTALLED_APPS: self.assets["js"].extend([{ "path": "core_file_preview_app/user/js/file_preview.js", "is_raw": False, }]) self.assets["css"].append( "core_file_preview_app/user/css/file_preview.css") self.modals.append( "core_file_preview_app/user/file_preview_modal.html") return render( request, "core_curate_app/user/data-review/view_data.html", assets=self.assets, context=self.build_context(request, curate_data_structure), modals=self.modals, ) except Exception as e: return render( request, "core_curate_app/user/errors.html", assets={}, context={"errors": str(e)}, )