def _render_table_display_page(
request: HttpRequest,
workflow: Workflow,
view: Optional[View],
columns,
ajax_url: str,
):
"""Render content of the display page.
Function to render the content of the display page taking into account
the columns to show and the AJAX url to use to render the table content.
:param request: HTTP request
:param workflow: Workflow object used to access the data frame
:param view: View to use to render the table (or None)
:param columns: Columns to display in the page
:param ajax_url: URL to invoke to populate the table
:return: HTTP Response
"""
# Create the initial context
context = {
'workflow': workflow,
'query_builder_ops': workflow.get_query_builder_ops_as_str(),
'ajax_url': ajax_url,
'views': workflow.views.all(),
'no_actions': workflow.actions.count() == 0,
'vis_scripts': PlotlyHandler.get_engine_scripts(),
}
# If there is a DF, add the columns
if workflow.has_table():
context['columns'] = columns
context['column_types'] = str([''] + [
col.data_type for col in columns])
context['columns_datatables'] = [{'data': 'Operations'}] + [
{'data': col.name.replace('.', '\\.')} for col in columns]
context['stat_columns'] = workflow.columns.filter(is_key=False)
else:
context['columns'] = None
context['columns_datatables'] = []
# If using a view, add it to the context
if view:
context['view'] = view
return render(request, 'table/display.html', context)
def edit_action_out(
request: HttpRequest,
workflow: Workflow,
action: Action,
) -> HttpResponse:
"""Edit action out.
:param request: Request object
:param workflow: The workflow with the action
:param action: Action
:return: HTML response
"""
# Create the form
form = EditActionOutForm(request.POST or None, instance=action)
form_filter = FilterForm(
request.POST or None,
instance=action.get_filter(),
action=action
)
# Processing the request after receiving the text from the editor
if request.method == 'POST' and form.is_valid() and form_filter.is_valid():
# Get content
text_content = form.cleaned_data.get('text_content')
# Render the content as a template and catch potential problems.
if text_renders_correctly(text_content, action, form):
# Log the event
Log.objects.register(
request.user,
Log.ACTION_UPDATE,
action.workflow,
{'id': action.id,
'name': action.name,
'workflow_id': workflow.id,
'workflow_name': workflow.name,
'content': text_content})
# Text is good. Update the content of the action
action.set_text_content(text_content)
if action.action_type == Action.personalized_json:
# Update the target_url field
action.target_url = form.cleaned_data['target_url']
action.save()
if request.POST['Submit'] == 'Submit':
return redirect(request.get_full_path())
return redirect('action:index')
# This is a GET request or a faulty POST request
# Get the filter or None
filter_condition = action.get_filter()
# Context to render the form
context = {
'filter_condition': filter_condition,
'action': action,
'load_summernote': action.action_type == Action.personalized_text,
'conditions': action.conditions.filter(is_filter=False),
'other_conditions': Condition.objects.filter(
action__workflow=workflow, is_filter=False,
).exclude(action=action),
'query_builder_ops': workflow.get_query_builder_ops_as_str(),
'attribute_names': [
attr for attr in list(workflow.attributes.keys())
],
'columns': workflow.columns.all(),
'stat_columns': workflow.columns.filter(is_key=False),
'selected_rows':
filter_condition.n_rows_selected
if filter_condition else -1,
'has_data': action.workflow.has_table(),
'all_false_conditions': any(
cond.n_rows_selected == 0
for cond in action.conditions.all()),
'rows_all_false': action.get_row_all_false_count(),
'total_rows': workflow.nrows,
'form': form,
'form_filter': form_filter,
'vis_scripts': PlotlyHandler.get_engine_scripts(),
}
# Return the same form in the same page
return render(request, 'action/edit_out.html', context=context)
def edit_action_in(
request: HttpRequest,
workflow: Workflow,
action: Action,
) -> HttpResponse:
"""Edit an action in.
:param request: Request object
:param workflow: workflow
:param action: Action
:return: HTTP response
"""
# All tuples (action, column, condition) to consider
tuples = action.column_condition_pair.all()
# Columns
all_columns = workflow.columns
# Conditions
filter_condition = action.get_filter()
all_conditions = action.conditions.filter(is_filter=False)
# Create the context info.
context = {
'action': action,
# Workflow elements
'total_rows': workflow.nrows,
'query_builder_ops': workflow.get_query_builder_ops_as_str(),
'has_data': workflow.has_table(),
'selected_rows':
filter_condition.n_rows_selected if filter_condition else -1,
'all_false_conditions': any(
cond.n_rows_selected == 0 for cond in all_conditions
),
# Column elements
'key_columns': all_columns.filter(is_key=True),
'stat_columns': all_columns.filter(is_key=False),
'key_selected': tuples.filter(column__is_key=True).first(),
'has_no_key': tuples.filter(column__is_key=False).exists(),
'any_empty_description': tuples.filter(
column__description_text='',
column__is_key=False,
).exists(),
'columns_to_insert': all_columns.exclude(
column_condition_pair__action=action,
).exclude(
is_key=True,
).distinct().order_by('position'),
'column_selected_table': ColumnSelectedTable(
tuples.filter(column__is_key=False).values(
'id',
'column__id',
'column__name',
'column__description_text',
'condition__name',
),
orderable=False,
extra_columns=[(
'operations',
OperationsColumn(
verbose_name='',
template_file=ColumnSelectedTable.ops_template,
template_context=lambda record: {
'id': record['column__id'],
'aid': action.id}),
)],
condition_list=all_conditions,
),
# Conditions
'filter_condition': filter_condition,
'conditions': all_conditions,
'vis_scripts': PlotlyHandler.get_engine_scripts(),
'other_conditions': Condition.objects.filter(
action__workflow=workflow, is_filter=False,
).exclude(action=action),
}
return render(request, 'action/edit_in.html', context)
