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
