def test_query_get_by_id_return_data_if_found(self, mock_get): # Arrange query = _create_query() mock_get.return_value = query # Act result = query_api.get_by_id(query.id) # Assert self.assertIsInstance(result, Query)
def get_data_source_list_federated(request): """ Ajax method to fill the list of data sources. Args: request: Returns: """ try: id_query = request.GET.get('id_query', None) if id_query is not None: # Get query from id query = api_query.get_by_id(id_query) instance_list = instance_api.get_all() item_list = [] for instance_item in instance_list: checked = False # Generate url from instance information url_instance = _get_url_with_federated_rest_extension( instance_item) # compare instance with existing data source in query # in order to know if they have to be checked for data_source_item in query.data_sources: if data_source_item.name == instance_item.name\ and data_source_item.url_query == url_instance: checked = True break # update the result item list for the context item_list.extend([{ 'instance_id': instance_item.id, 'instance_name': instance_item.name, 'is_checked': checked }]) # Here, data sources are instances context_params = dict() context_params['instances'] = item_list # return context context = {} context.update(request) context.update(context_params) return render( request, 'core_explore_federated_search_app/user/data_sources/list-content.html', context) else: return HttpResponseBadRequest( "Error during loading data sources from federated search.") except Exception as e: return HttpResponseBadRequest( "Error during loading data sources from federated search.")
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)
def get_data_source_list_oaipmh(request): """Ajax method to fill the list of data sources. Args: request: Returns: """ try: id_query = request.GET.get("id_query", None) if id_query is not None: # Get query from id query = api_query.get_by_id(id_query, request.user) instance_list = oai_registry_api.get_all_activated_registry( order_by_field="name") item_list = [] for instance_item in instance_list: checked = False # compare instance with existing data source in query # in order to know if they have to be checked for data_source_item in query.data_sources: if ("instance_id" in data_source_item.query_options and data_source_item.query_options["instance_id"] == str(instance_item.id)): checked = True # update the result item list for the context item_list.extend([{ "instance_id": instance_item.id, "instance_name": instance_item.name, "is_checked": checked, }]) # Here, data sources are instances context_params = dict() context_params["instances"] = item_list # return context context = {} context.update(request) context.update(context_params) return render( request, "core_explore_oaipmh_app/user/data_sources/list-content.html", context, ) else: return HttpResponseBadRequest( "Error during loading data sources from oaipmh search.") except AccessControlError: return HttpResponseForbidden() except Exception as e: return HttpResponseBadRequest( "Error during loading data sources from oaipmh search: %s" % escape(str(e)))
def get(self, request, *args, **kwargs): try: # Get the query query_id = request.GET.get('query_id', None) self.request = request self.query = query_api.get_by_id(query_id) # Build the count self.build_count() except Exception, e: return HttpResponseBadRequest("Something wrong happened.")
def update_data_source_list_oaipmh(request): """Ajax method to update query data sources in data base. Args: request: Returns: """ try: id_query = request.GET.get("id_query", None) id_instance = request.GET.get("id_instance", None) added = request.GET.get("to_be_added", None) to_be_added = json.loads(added) if added is not None else False # Get query from id if id_query is not None: query = api_query.get_by_id(id_query, request.user) url_instance = request.build_absolute_uri( reverse("core_explore_oaipmh_rest_execute_query")) instance = oai_registry_api.get_by_id(id_instance) if to_be_added: # Instance have to be added in the query as a data source authentication = Authentication(type="session") data_source = DataSource( name=instance.name, url_query=url_instance, authentication=authentication, order_by_field=",".join(DATA_SORTING_FIELDS), ) data_source.query_options = {"instance_id": str(instance.id)} if "core_linked_records_app" in settings.INSTALLED_APPS: data_source.capabilities = { "url_pid": request.build_absolute_uri( reverse("core_linked_records_app_query_oaipmh")) } api_oaipmh_query.add_oaipmh_data_source( query, data_source, request.user) else: api_oaipmh_query.remove_oaipmh_data_source( query, id_instance, request.user) return HttpResponse() else: return HttpResponseBadRequest( "Error during data source selection.") except AccessControlError: return HttpResponseForbidden() except Exception as e: return HttpResponseBadRequest( "Error during data source selection: %s" % escape(str(e)))
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 get_data_source_results(request, query_id, data_source_index, page=1): """Gets results from a data source Args: request: query_id: data_source_index: page: Returns: """ try: # get query query = query_api.get_by_id(query_id) # send query, and get results from data source results = send_query(request, query, int(data_source_index), page) # set results in context context_data = { 'results': results['results'], 'query_id': query_id, 'data_source_index': data_source_index, 'pagination': { 'number': int(page), 'paginator': {'num_pages': int(math.ceil(float(results['count']) / RESULTS_PER_PAGE))}, 'has_other_pages': results['count'] > RESULTS_PER_PAGE, 'previous_page_number': get_page_number(results['previous']), 'next_page_number': get_page_number(results['next']), 'has_previous': get_page_number(results['previous']) is not None, 'has_next': get_page_number(results['next']) > int(math.ceil(float(results['count']) / RESULTS_PER_PAGE)), }, 'exporter_app': 'core_exporters_app' in INSTALLED_APPS } # create context context = {} context.update(request) context.update(context_data) # generate html with context html_template = loader.get_template(join('core_explore_common_app', 'user', 'results', 'data_source_results.html')) # render html results_html = html_template.render(context) # set response with html results response_dict = {'results': results_html, 'nb_results': results['count']} return HttpResponse(json.dumps(response_dict), content_type='application/json') except ExploreRequestError, ex: return HttpResponseBadRequest("An error occurred while sending the query: " + ex.message)
def _post(self, request): """ Update the POST context Args: request: Returns: """ context = super(KeywordSearchRegistryView, self)._post(request) # get refinement form refinement_form = RefinementForm(data=request.POST) # get query_id and error from the context error = context.get("error", None) query_id = context.get("query_id", None) # validate form, test if no errors occurred in the parent treatment and query_id exists if refinement_form.is_valid( ) and error is None and query_id is not None: try: query = query_api.get_by_id(query_id) content = json.loads(query.content) refinements = [] # Update content with status update_content_not_deleted_status_criteria(content) # get selected refinements (categories) for refinement_name, selected_categories in refinement_form.cleaned_data.iteritems( ): if len(selected_categories) > 0: # Add categories ids refinements.append([x.id for x in selected_categories]) # generate query if len(refinements) > 0: # get refinement query refinement_query = mongo_query_api.build_refinements_query( refinements) # if we have a refinement query if len(refinement_query.keys()) > 0: content.update(refinement_query) # Update content query.content = json.dumps(content) # save query query_api.upsert(query) except DoesNotExist: error = "An unexpected error occurred while retrieving the query." context.update({'error': error}) except Exception, e: error = "An unexpected error occurred: {}.".format(e.message) context.update({'error': error})
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}
def get_data_sources_html(request): """Gets data sources html for results Args: request: Returns: """ try: # get query id query_id = request.GET["query_id"] # get query results query = query_api.get_by_id(query_id, request.user) # Check if 'core_linked_records_app' is installed and activated is_linked_records_installed = False if "core_linked_records_app" in settings.INSTALLED_APPS: from core_linked_records_app.components.pid_settings import ( api as pid_settings_api, ) is_linked_records_installed = pid_settings_api.get().auto_set_pid # set query in context context = { "linked_records_app": is_linked_records_installed, "exporter_app": "core_exporters_app" in settings.INSTALLED_APPS, "sorting_display_type": settings.SORTING_DISPLAY_TYPE, "data_displayed_sorting_fields": settings.DATA_DISPLAYED_SORTING_FIELDS, "default_date_toggle_value": settings.DEFAULT_DATE_TOGGLE_VALUE, } context.update(request) context.update({"query": query}) # render html results html_template = loader.get_template( join( "core_explore_common_app", "user", "results", "data_sources_results.html", ) ) html_results_holders = html_template.render(context) response_dict = {"results": html_results_holders} return HttpResponse(json.dumps(response_dict), content_type="application/json") except Exception as e: return HttpResponseBadRequest(escape(str(e)))
def _post(self, request): """ Prepare the POST context Args: request: Returns: """ error = None warning = None search_form = KeywordForm(data=request.POST) display_persistent_query_button = False # validate form if search_form.is_valid(): try: # get form values query_id = search_form.cleaned_data.get('query_id', None) keywords = search_form.cleaned_data.get('keywords', 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 None or keywords is None: error = "Expected parameters are not provided" else: # get query query = query_api.get_by_id(query_id) if len(query.data_sources) == 0: warning = "Please select at least 1 data source." else: # update query query.templates = template_api.get_all_by_id_list( template_ids) query.content = json.dumps( get_full_text_query(keywords)) query_api.upsert(query) display_persistent_query_button = True except DoesNotExist: error = "An unexpected error occurred while retrieving the query." except Exception, e: error = "An unexpected error occurred: {}.".format(e.message)
def update_data_source_list_federated(request): """ Ajax method to update query data sources in bdd. Args: request: Returns: """ try: id_query = request.GET.get('id_query', None) id_instance = request.GET.get('id_instance', None) added = request.GET.get('to_be_added', None) to_be_added = json.loads(added) if added is not None else False # Get query from id if id_query is not None: query = api_query.get_by_id(id_query) # Get instance from id if id_instance is not None: instance = instance_api.get_by_id(id_instance) # Generate url from instance information url = _get_url_with_federated_rest_extension(instance) if to_be_added: # Instance have to be added in the query as a datasource authentication = Authentication( type='oauth2', params={'access_token': instance.access_token}) data_source = DataSource(name=instance.name, url_query=url, authentication=authentication) data_source.query_options = {'instance_name': instance.name} api_query.add_data_source(query, data_source) else: # Data source have to be remove from the query data_source = api_query.get_data_source_by_name_and_url_query( query, instance.name, url) api_query.remove_data_source(query, data_source) return HttpResponse() else: return HttpResponseBadRequest( "Error during data source selection.") except Exception as e: return HttpResponseBadRequest("Error during data source selection.")
def get_local_data_source(request): """Ajax method to get the local data source Args: request: Returns: """ try: id_query = request.GET.get("query_id", None) if id_query is not None: # Get query from id query = query_api.get_by_id(id_query, request.user) context_params = { "enabled": True, "selected": False, } if len(settings.DATA_SOURCES_EXPLORE_APPS) == 0: add_local_data_source(request, query) context_params["enabled"] = False # check query to see if local data source was selected local_query_url = get_local_query_absolute_url(request) for data_source in query.data_sources: if ( data_source.name == LOCAL_QUERY_NAME and data_source.url_query == local_query_url ): context_params["selected"] = True context = {} context.update(request) context.update(context_params) return django_render( request, "core_explore_common_app/user/selector/local_content.html", context=context, ) else: return HttpResponseBadRequest("Expected query_id parameter is missing.") except Exception as e: return HttpResponseBadRequest( "An unexpected error occurred while getting local data source selector." )
def get_data_source_list_oaipmh(request): """ Ajax method to fill the list of data sources. Args: request: Returns: """ try: id_query = request.GET.get('id_query', None) if id_query is not None: # Get query from id query = api_query.get_by_id(id_query) instance_list = oai_registry_api.get_all_activated_registry(order_by_field='name') item_list = [] url_instance = request.build_absolute_uri(reverse("core_explore_oaipmh_rest_execute_query")) for instance_item in instance_list: checked = False # compare instance with existing data source in query # in order to know if they have to be checked for data_source_item in query.data_sources: if data_source_item.name == instance_item.name\ and data_source_item.url_query == url_instance: checked = True break # update the result item list for the context item_list.extend([{'instance_id': instance_item.id, 'instance_name': instance_item.name, 'is_checked': checked}]) # Here, data sources are instances context_params = dict() context_params['instances'] = item_list # return context context = {} context.update(request) context.update(context_params) return render(request, 'core_explore_oaipmh_app/user/data_sources/list-content.html', context) else: return HttpResponseBadRequest("Error during loading data sources from oaipmh search.") except Exception as e: return HttpResponseBadRequest("Error during loading data sources from oaipmh search: %s" % e.message)
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')
def get_local_data_source(request): """ Ajax method to get the local data source Args: request: Returns: """ try: id_query = request.GET.get('query_id', None) if id_query is not None: # Get query from id query = query_api.get_by_id(id_query) context_params = { 'enabled': True, 'selected': False, } if len(DATA_SOURCES_EXPLORE_APPS) == 0: add_local_data_source(request, query) context_params['enabled'] = False # check query to see if local data source was selected local_query_url = get_local_query_absolute_url(request) for data_source in query.data_sources: if data_source.name == LOCAL_QUERY_NAME and data_source.url_query == local_query_url: context_params['selected'] = True context = {} context.update(request) context.update(context_params) template = loader.get_template('core_explore_common_app/user/selector/local_content.html') html_data_source = template.render(context) return HttpResponse(html_data_source) else: return HttpResponseBadRequest("Expected query_id parameter is missing.") except Exception as e: return HttpResponseBadRequest("An unexpected error occurred while getting local data source selector.")
def update_data_source_list_oaipmh(request): """ Ajax method to update query data sources in data base. Args: request: Returns: """ try: id_query = request.GET.get('id_query', None) id_instance = request.GET.get('id_instance', None) added = request.GET.get('to_be_added', None) to_be_added = json.loads(added) if added is not None else False # Get query from id if id_query is not None: query = api_query.get_by_id(id_query) url_instance = request.build_absolute_uri(reverse("core_explore_oaipmh_rest_execute_query")) instance = oai_registry_api.get_by_id(id_instance) if to_be_added: # Instance have to be added in the query as a data source authentication = Authentication(type='session') data_source = DataSource(name=instance.name, url_query=url_instance, authentication=authentication) data_source.query_options = {'instance_id': str(instance.id)} api_query.add_data_source(query, data_source) else: # Data source have to be remove from the query data_source = api_query.get_data_source_by_name_and_url_query(query, instance.name, url_instance) api_query.remove_data_source(query, data_source) return HttpResponse() else: return HttpResponseBadRequest("Error during data source selection.") except Exception as e: return HttpResponseBadRequest("Error during data source selection: %s" % e.message)
def update_data_source_list_federated(request): """Ajax method to update query data sources in bdd. Args: request: Returns: """ try: id_query = request.GET.get("id_query", None) id_instance = request.GET.get("id_instance", None) added = request.GET.get("to_be_added", None) to_be_added = json.loads(added) if added is not None else False # Get query from id if id_query is not None: query = api_query.get_by_id(id_query, request.user) # Get instance from id if id_instance is not None: instance = instance_api.get_by_id(id_instance) # Generate url from instance information url = _get_url_with_federated_rest_extension(instance) if to_be_added: # Instance have to be added in the query as a datasource authentication = Authentication( type="oauth2", params={"access_token": instance.access_token}) data_source = DataSource( name=instance.name, url_query=url, authentication=authentication, order_by_field=",".join(settings.DATA_SORTING_FIELDS), ) data_source.query_options = {"instance_name": instance.name} if "core_linked_records_app" in settings.INSTALLED_APPS: data_source.capabilities = { "url_pid": urljoin( instance.endpoint, reverse("core_linked_records_app_query_local"), ) } api_query.add_data_source(query, data_source, request.user) else: # Data source have to be remove from the query data_source = api_query.get_data_source_by_name_and_url_query( query, instance.name, url, request.user) api_query.remove_data_source(query, data_source, request.user) return HttpResponse() else: return HttpResponseBadRequest( "Error during data source selection.") except AccessControlError: return HttpResponseForbidden("Access Forbidden") except Exception: return HttpResponseBadRequest("Error during data source selection.")
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", )
def _get(self, user, query_id): """Update the GET context Args: user: query_id: Returns: """ context = super(KeywordSearchRegistryView, self)._get(user, query_id) data_form = {} refinement_selected_types = [] category_list = "" query_id = context.get("query_id", None) # in case we don't find the query id in the context # a default query is created by inheritance if query_id is None: return {"error": "query id is missing"} try: # get the query id query = query_api.get_by_id(query_id, self.request.user) # here we have to make sure to set the visibility and status criteria # set visibility query_api.set_visibility_to_query(query, self.request.user) # load content content = json.loads(query.content) # update content with status update_content_not_deleted_status_criteria(content) query.content = json.dumps(content) # save query query_api.upsert(query, self.request.user) # get all keywords back refinement_selected_values = ( mongo_query_api.get_refinement_selected_values_from_query( content, self.request)) # build the data_form structure for key in refinement_selected_values: for display_name in refinement_selected_values[key]: list_element = refinement_selected_values[key][ display_name] data_form.update({ RefinementForm.prefix + "-" + key: [element["id"] for element in list_element] }) # add the selected type only for the display_name = Type if display_name == "Type": refinement_selected_types = [ element["value"] for element in list_element ] # create the list of category if len(refinement_selected_values[key]) > 0: category_list = "%s,%s|%s" % (category_list, display_name, key) context.update({"category_list": category_list}) except Exception as e: context.update({ "error": "An unexpected error occurred while loading the query: %s." % str(e) }) context.update({ "refinement_form": RefinementForm(data=data_form, request=self.request) }) # get all categories which must be selected in the table context.update( {"refinement_selected_types": refinement_selected_types}) # Custom registry self._update_context_with_custom_resources(context) return context
def get_data_source_results(request, query_id, data_source_index, page=1): """Gets results from a data source Args: request: query_id: data_source_index: page: Returns: """ try: # get query query = query_api.get_by_id(query_id, request.user) # send query, and get results from data source results = send_query(request, query, int(data_source_index), page) # get pagination information previous_page_number = get_page_number(results["previous"]) next_page_number = get_page_number(results["next"]) results_count = results["count"] page_count = int(math.ceil(float(results_count) / settings.RESULTS_PER_PAGE)) # pagination has other pages? has_other_pages = results_count > settings.RESULTS_PER_PAGE # pagination has previous? has_previous = previous_page_number is not None # pagination has next? has_next = next_page_number is not None and next_page_number <= page_count # set results in context context_data = { "results": results["results"], "query_id": query_id, "data_source_index": data_source_index, "pagination": { "number": int(page), "paginator": {"num_pages": page_count}, "has_other_pages": has_other_pages, "previous_page_number": previous_page_number, "next_page_number": next_page_number, "has_previous": has_previous, "has_next": has_next, }, "blobs_preview": "core_file_preview_app" in settings.INSTALLED_APPS, "display_edit_button": settings.DISPLAY_EDIT_BUTTON, "exporter_app": "core_exporters_app" in settings.INSTALLED_APPS, } # create context context = {} context.update(request) context.update(context_data) # generate html with context html_template = loader.get_template( join( "core_explore_common_app", "user", "results", "data_source_results.html" ) ) # render html results_html = html_template.render(context) # set response with html results response_dict = {"results": results_html, "nb_results": results["count"]} return HttpResponse(json.dumps(response_dict), content_type="application/json") except ExploreRequestError as ex: return HttpResponseBadRequest( "An error occurred while sending the query: " + escape(str(ex)), ) except Exception as e: return HttpResponseBadRequest( "An unexpected error occurred: " + escape(str(e)), )
def post(self, request): try: # FIXME duplicated code with core_explore_common.utils.query.send query = query_api.get_by_id(request.POST["query_id"], request.user) data_source = query.data_sources[int( request.POST["data_source_index"])] # Build serialized query to send to data source json_query = { "query": query.content, "templates": json.dumps([{ "id": str(template.id), "hash": template.hash } for template in query.templates]), "options": json.dumps(data_source.query_options), "order_by_field": data_source.order_by_field, } if (getattr(data_source, "capabilities", False) and "url_pid" not in data_source.capabilities.keys()): return JsonResponse( {"error": "The remote does not have PID capabilities."}, status=status.HTTP_500_INTERNAL_SERVER_ERROR, ) if data_source.authentication.type == "session": response = send_get_request( data_source.capabilities["url_pid"], data=json_query, cookies={"sessionid": request.session.session_key}, ) elif data_source.authentication.type == "oauth2": response = oauth2_post_request( data_source.capabilities["url_pid"], json_query, data_source.authentication.params["access_token"], session_time_zone=timezone.get_current_timezone(), ) else: raise Exception("Unknown authentication type.") if response.status_code == 200: return JsonResponse( { "pids": [pid for pid in response.json() if pid is not None] }, status=response.status_code, ) else: return JsonResponse( { "error": "Remote service answered with status code %d." % response.status_code }, status=response.status_code, ) except Exception as exception: return JsonResponse({"error": str(exception)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
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)
def test_saved_query_get_by_id_raises_api_error_if_not_found(self, mock_get): # Arrange mock_get.side_effect = exceptions.DoesNotExist('') # Act # Assert with self.assertRaises(exceptions.DoesNotExist): query_api.get_by_id("1")
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)}, )
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})
def _post(self, request): """Update the POST context Args: request: Returns: """ context = super(KeywordSearchRegistryView, self)._post(request) # get refinement form refinement_form = RefinementForm(data=request.POST, request=request) # get query_id and error from the context error = context.get("error", None) query_id = context.get("query_id", None) refinement_selected_types = [] # validate form, test if no errors occurred in the parent treatment and query_id exists if refinement_form.is_valid( ) and error is None and query_id is not None: try: query = query_api.get_by_id(query_id, request.user) content = json.loads(query.content) refinements = [] # Update content with status update_content_not_deleted_status_criteria(content) # get selected refinements (categories) for refinement_name, selected_categories in list( refinement_form.cleaned_data.items()): if len(selected_categories) > 0: # Add categories ids refinements.append([x.id for x in selected_categories]) # generate query if len(refinements) > 0: # get refinement query refinement_query = mongo_query_api.build_refinements_query( refinements) # if we have a refinement query if len(list(refinement_query.keys())) > 0: if ("$and" in content.keys() and "$and" in refinement_query.keys()): content["$and"] += refinement_query["$and"] elif ("$or" in content.keys() or "$text" in content.keys() ) and "$and" in refinement_query.keys(): new_content = refinement_query # copy the text or the search operators in the main $and for key, value in content.items(): if key == "$or" or key == "$text": key_pair = {} key_pair[key] = value new_content["$and"].append(key_pair) else: new_content[key] = value content = new_content else: content.update(refinement_query) # Update content query.content = json.dumps(content) # save query query_api.upsert(query, request.user) except DoesNotExist: error = "An unexpected error occurred while retrieving the query." context.update({"error": error}) except Exception as e: error = "An unexpected error occurred: {}.".format(str(e)) context.update({"error": error}) context.update({"refinement_form": refinement_form}) # get all categories which must be selected in the table if refinement_form.cleaned_data: # get the current template template = template_registry_api.get_current_registry_template( request=request) # get the refinement 'Type' refinement = refinement_api.get_by_template_hash_and_by_slug( template.hash, "type") # get the selected_types selected_types = refinement_form.cleaned_data.get( refinement.slug, None) # create the list of type if selected_types: refinement_selected_types = get_all_parent_name_from_category_list( selected_types) # create the list of category category_list = "" for key in refinement_form.cleaned_data: if len(refinement_form.cleaned_data[key]) > 0: category_list = "%s,%s|%s" % ( category_list, refinement_form.cleaned_data[key][0].refinement.name, key, ) context.update({"category_list": category_list}) # get all categories which must be selected in the table context.update( {"refinement_selected_types": refinement_selected_types}) # Custom registry self._update_context_with_custom_resources(context) return context