def get_table(self, **kwargs):
# set some custom attributes for template rendering
table = super(WmsIndexView, self).get_table(**kwargs)
# whether whole services or single layers should be displayed, we have to exclude some columns
filter_by_show_layers = self.filterset.form_prefix + '-' + 'service__is_root'
if filter_by_show_layers in self.filterset.data and self.filterset.data.get(
filter_by_show_layers) == 'on':
table.exclude = (
'layers',
'featuretypes',
'harvest_results',
'collected_harvest_records',
'harvest_duration',
)
else:
table.exclude = (
'parent_service',
'featuretypes',
'harvest_results',
'collected_harvest_records',
'harvest_duration',
)
render_helper = RenderHelper(user_permissions=list(
filter(None, self.request.user.get_all_permissions())))
table.actions = [
render_helper.render_item(item=Metadata.get_add_resource_action())
]
return table
def get_table(self, **kwargs):
# set some custom attributes for template rendering
table = super(LogsIndexView, self).get_table(**kwargs)
table.title = Tag(tag='i', attrs={"class": [IconEnum.LOGS.value]
}) + _(' Logs')
render_helper = RenderHelper(user_permissions=list(
filter(None, self.request.user.get_all_permissions())),
update_url_qs=get_current_view_args(
self.request))
# append export links
query_trailer_sign = "?"
if self.request.GET:
query_trailer_sign = "&"
csv_download_link = Link(url=self.request.get_full_path() +
f"{query_trailer_sign}_export=csv",
content=".csv")
json_download_link = Link(url=self.request.get_full_path() +
f"{query_trailer_sign}_export=json",
content=".json")
dropdown = Dropdown(btn_value=Tag(
tag='i', attrs={"class": [IconEnum.DOWNLOAD.value]}) +
_(" Export as"),
items=[csv_download_link, json_download_link],
needs_perm=PermissionEnum.CAN_ACCESS_LOGS.value)
table.actions = [render_helper.render_item(item=dropdown)]
return table
def get_table(self, **kwargs):
# set some custom attributes for template rendering
table = super(DatasetIndexView, self).get_table(**kwargs)
render_helper = RenderHelper(user_permissions=list(
filter(None, self.request.user.get_all_permissions())),
update_url_qs=get_current_view_args(
self.request))
table.actions = [
render_helper.render_item(item=Metadata.get_add_dataset_action())
]
return table
class PendingTaskTable(tables.Table):
bs4helper = None
status = tables.Column(verbose_name=_('Status'),
accessor='status_icons',
attrs={"th": {
"class": "col-sm-1"
}})
service = tables.Column(verbose_name=_('Service'),
accessor='service_uri',
attrs={"th": {
"class": "col-sm-3"
}})
phase = tables.Column(verbose_name=_('Phase'),
attrs={"th": {
"class": "col-sm-4"
}})
progress = tables.Column(verbose_name=_('Progress'),
attrs={"th": {
"class": "col-sm-3"
}})
actions = tables.Column(verbose_name=_('Actions'),
accessor='action_buttons',
attrs={
"td": {
"style": "white-space:nowrap;"
},
"th": {
"class": "col-sm-1"
}
})
class Meta:
model = PendingTask
fields = ('status', 'service', 'phase', 'progress', 'actions')
template_name = "skeletons/django_tables2_bootstrap4_custom.html"
prefix = 'pending-task-table'
orderable = False
def before_render(self, request):
self.render_helper = RenderHelper(user_permissions=list(
filter(None, request.user.get_all_permissions())))
def render_status(self, value):
return format_html(self.render_helper.render_list_coherent(value))
def render_actions(self, value):
self.render_helper.update_attrs = {"class": ["btn-sm"]}
renderd_actions = self.render_helper.render_list_coherent(items=value)
self.render_helper.update_attrs = None
return format_html(renderd_actions)
@staticmethod
def render_progress(value):
return ProgressBar(progress=round(value, 2)).render(safe=True)
def get_table(self, **kwargs):
# set some custom attributes for template rendering
table = super(CswIndexView, self).get_table(**kwargs)
table.exclude = ('parent_service', 'layers', 'featuretypes',
'service__published_for')
render_helper = RenderHelper(user_permissions=list(
filter(None, self.request.user.get_all_permissions())),
update_url_qs=get_current_view_args(
self.request))
table.actions = [
render_helper.render_item(item=Metadata.get_add_resource_action())
]
return table
def get_table(self, **kwargs):
# set some custom attributes for template rendering
table = super(WfsIndexView, self).get_table(**kwargs)
table.exclude = ('parent_service', 'layers', 'harvest_results',
'collected_harvest_records', 'harvest_duration')
render_helper = RenderHelper(user_permissions=list(
filter(None, self.request.user.get_all_permissions())),
update_url_qs=get_current_view_args(
self.request))
table.actions = [
render_helper.render_item(item=Metadata.get_add_resource_action())
]
return table
class SubscriptionTable(tables.Table):
render_helper = None
actions = MrMapColumn(verbose_name=_('Actions'),
tooltip=_('Actions to perform'),
empty_values=[],
orderable=False,
attrs={"td": {
"style": "white-space:nowrap;"
}})
class Meta:
model = Subscription
fields = ('metadata', 'notify_on_update', 'notify_on_metadata_edit',
'notify_on_access_edit')
template_name = "skeletons/django_tables2_bootstrap4_custom.html"
prefix = 'subscription-table'
def before_render(self, request):
self.render_helper = RenderHelper(user_permissions=list(
filter(None, request.user.get_all_permissions())))
def render_metadata(self, value):
return Link(url=value.get_absolute_url(),
content=value).render(safe=True)
def render_actions(self, record):
self.render_helper.update_attrs = {"class": ["btn-sm", "mr-1"]}
renderd_actions = self.render_helper.render_list_coherent(
items=record.get_actions())
self.render_helper.update_attrs = None
return format_html(renderd_actions)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
related_datasets = self.object.get_related_dataset_metadatas()
item_list = []
for related_dataset in related_datasets:
link_to_dataset = Link(url=related_dataset.detail_view_uri,
content=related_dataset.title)
metadata_xml = Link(url=related_dataset.service_metadata_uri,
content=get_icon(IconEnum.CAPABILITIES) +
_(' XML'),
open_in_new_tab=True)
metadata_html = Link(url=related_dataset.html_metadata_uri,
content=get_icon(IconEnum.NEWSPAPER) +
_(' HTML'),
open_in_new_tab=True)
dataset_metadata_dropdown = Dropdown(
btn_value=get_icon(IconEnum.METADATA) + _(' Metadata'),
items=[metadata_xml, metadata_html],
color=ButtonColorEnum.SECONDARY,
header=_l('Show metadata as:'))
render_helper = RenderHelper(
user_permissions=list(
filter(None, self.request.user.get_all_permissions())),
update_url_qs=get_current_view_args(request=self.request),
update_attrs={"class": ["btn-sm", "mr-1"]})
right = render_helper.render_list_coherent(
items=related_dataset.get_actions())
item_content = DefaultHeaderRow(
content_left=link_to_dataset.render(),
content_center=dataset_metadata_dropdown.render(),
content_right=right)
item_list.append(ListGroupItem(content=item_content.render()))
dataset_list = ListGroup(items=item_list)
context.update({'card_body': dataset_list if related_datasets else ''})
return context
def get_table(self, **kwargs):
# set some custom attributes for template rendering
table = super(AllowedOperationTableView, self).get_table(**kwargs)
table.title = Tag(tag='i', attrs={"class": [IconEnum.ACCESS.value]}).render() + f' Allowed Operations for {self.root_metadata}'
render_helper = RenderHelper(user_permissions=list(filter(None, self.request.user.get_all_permissions())),
update_url_qs=get_current_view_args(self.request))
#table.actions = [render_helper.render_item(item=Metadata.get_add_resource_action())]
return table
class MonitoringRunTable(tables.Table):
class Meta:
model = MonitoringRun
fields = ('uuid', 'metadatas__all', 'start', 'end', 'duration')
template_name = "skeletons/django_tables2_bootstrap4_custom.html"
prefix = 'monitoring-result-table'
health_state = tables.Column(accessor='health_state',
verbose_name=_('Related health state'))
results = tables.Column(verbose_name=_('Related results'), empty_values=[])
def before_render(self, request):
self.render_helper = RenderHelper(user_permissions=list(
filter(None, request.user.get_all_permissions())))
def render_uuid(self, record, value):
return Link(url=record.get_absolute_url(),
content=value).render(safe=True)
def render_metadatas__all(self, value):
links = []
for metadata in value:
links.append(
Tag(tag='span',
attrs={"class": ['mr-1']},
content=Link(url=metadata.get_absolute_url(),
content=metadata).render() + ','))
return format_html(
self.render_helper.render_list_coherent(items=links))
def render_results(self, record):
if record.result_view_uri:
return Link(url=record.result_view_uri,
content=_('results')).render(safe=True)
else:
return ''
def render_health_state(self, value):
if value.health_state_code == HealthStateEnum.WARNING.value:
color = TextColorEnum.WARNING
elif value.health_state_code == HealthStateEnum.CRITICAL.value:
color = TextColorEnum.DANGER
elif value.health_state_code == HealthStateEnum.UNAUTHORIZED.value:
color = TextColorEnum.SECONDARY
else:
color = TextColorEnum.SUCCESS
return Link(url=value.get_absolute_url, color=color,
content=value.pk).render(safe=True)
def setup(self, request, *args, **kwargs):
super().setup(request, *args, **kwargs)
self.render_helper = RenderHelper(
user_permissions=list(
filter(None, self.request.user.get_all_permissions())),
update_attrs={"class": ["btn-sm", "mr-1"]})
def before_render(self, request):
self.render_helper = RenderHelper(user_permissions=list(
filter(None, request.user.get_all_permissions())))
class DatasetTable(tables.Table):
bs4helper = None
related_objects = MrMapColumn(verbose_name=_('Related objects'),
accessor='related_to__all',
empty_values=[])
origins = MrMapColumn(verbose_name=_('Origins'), empty_values=[])
actions = tables.Column(verbose_name=_('Actions'),
empty_values=[],
orderable=False,
attrs={"td": {
"style": "white-space:nowrap;"
}})
class Meta:
model = Metadata
fields = ('title', 'related_objects', 'origins', 'actions')
template_name = "skeletons/django_tables2_bootstrap4_custom.html"
# todo: set this prefix dynamic
prefix = 'wms-table'
def before_render(self, request):
self.render_helper = RenderHelper(user_permissions=list(
filter(None, request.user.get_all_permissions())))
def render_title(self, value, record):
return Link(url=record.detail_html_view_uri,
content=value,
open_in_new_tab=True).render(safe=True)
def render_related_objects(self, value):
link_list = []
for metadata in value:
if metadata.metadata_type == MetadataEnum.FEATURETYPE.value:
kind_of_resource_icon = IconEnum.FEATURETYPE.value
kind_of_resource = "Featuretype"
elif metadata.metadata_type == MetadataEnum.LAYER.value:
kind_of_resource_icon = IconEnum.LAYER.value
kind_of_resource = "Layer"
else:
kind_of_resource_icon = ""
kind_of_resource = ""
kind_of_resource_icon = Tag(
tag='i',
attrs={
"class": [kind_of_resource_icon]
},
).render()
link_list.append(
Link(
url=metadata.detail_view_uri,
content=format_html(kind_of_resource_icon +
f" {metadata.title} [{metadata.id}]"),
tooltip=
_(f'Click to open the detail view of related {kind_of_resource} <strong>{metadata.title} [{metadata.id}]"</strong>'
),
), )
return format_html(
self.render_helper.render_list_coherent(items=link_list))
def render_origins(self, record):
related_metadatas = MetadataRelation.objects.filter(to_metadata=record)
origin_list = []
rel_mds = list(record.related_metadatas.all())
relations = list(related_metadatas) + rel_mds
for relation in relations:
origin_list.append(f"{relation.origin}")
return format_html(', '.join(origin_list))
def render_actions(self, record):
self.render_helper.update_attrs = {"class": ["btn-sm", "mr-1"]}
renderd_actions = self.render_helper.render_list_coherent(
items=record.get_actions())
self.render_helper.update_attrs = None
return format_html(renderd_actions)
class OgcServiceTable(tables.Table):
bs4helper = None
layers = tables.Column(verbose_name=_('Layers'),
empty_values=[],
accessor='service__child_services__count')
featuretypes = tables.Column(verbose_name=_('Featuretypes'),
empty_values=[],
accessor='service__featuretypes__count')
parent_service = tables.Column(
verbose_name=_('Parent service'),
empty_values=[],
accessor='service__parent_service__metadata')
status = tables.Column(verbose_name=_('Status'),
empty_values=[],
attrs={"td": {
"style": "white-space:nowrap;"
}})
health = tables.Column(
verbose_name=_('Health'),
empty_values=[],
)
harvest_results = tables.Column(
verbose_name=_('Last harvest'),
empty_values=[],
)
harvest_duration = tables.Column(verbose_name=_('Harvest duration'),
empty_values=[],
accessor='harvest_results')
collected_harvest_records = tables.Column(
verbose_name=_('Collected harvest records'),
empty_values=[],
accessor='harvest_results')
actions = tables.TemplateColumn(
verbose_name=_('Actions'),
empty_values=[],
orderable=False,
template_code=RESOURCE_TABLE_ACTIONS,
attrs={"td": {
"style": "white-space:nowrap;"
}})
class Meta:
model = Metadata
fields = ('title', 'layers', 'featuretypes', 'parent_service',
'status', 'health', 'service__service_type__version',
'harvest_results', 'harvest_duration',
'collected_harvest_records', 'contact',
'service__created_by__mrmapgroup', 'service__published_for',
'created', 'actions')
template_name = "skeletons/django_tables2_bootstrap4_custom.html"
prefix = 'ogc-service-table'
def before_render(self, request):
self.render_helper = RenderHelper(user_permissions=list(
filter(None, request.user.get_all_permissions())))
def render_title(self, record, value):
return Link(url=record.detail_view_uri,
content=value).render(safe=True)
def render_harvest_results(self, value):
last_harvest_result = value.all().first()
return last_harvest_result.timestamp_start if last_harvest_result is not None else _(
'Never')
def render_collected_harvest_records(self, record, value):
last_harvest_result = value.all().first()
dataset_count = record.get_related_metadatas().filter(
metadata_type=MetadataEnum.DATASET.value).count()
link = f"<a data-toggle='tooltip' title='{_('Number of dataset metadata harvested')}'href='{reverse('resource:datasets-index')}?dataset-filter-related_to={record.pk}'>{dataset_count}</a>"
return format_html(f"{last_harvest_result.number_results} ({link})"
) if last_harvest_result is not None else '-'
def render_harvest_duration(self, value):
last_harvest_result = value.all().first()
if last_harvest_result and last_harvest_result.timestamp_end and last_harvest_result.timestamp_start:
time_delta = last_harvest_result.timestamp_end - last_harvest_result.timestamp_start
return f"{time_delta.days}d {time_delta.seconds//3600}h {(time_delta.seconds//60)%60}m {(time_delta.seconds)%60}s"
else:
return '-'
# todo
def render_wms_validation(self, record):
passed = None
try:
check_run = ConformityCheckRun.objects.get_latest_check(record)
passed = check_run.passed
except ConformityCheckRun.DoesNotExist:
pass
return self.get_validation_icons(passed=passed)
def render_parent_service(self, value):
return Link(url=value.detail_view_uri, content=value).render(safe=True)
def render_status(self, record):
self.render_helper.update_attrs = {'class': ['mr-1']}
update_url_qs = self.render_helper.update_url_qs
self.render_helper.update_url_qs = {}
icons = self.render_helper.render_list_coherent(
items=record.get_status_icons(), safe=True)
self.render_helper.update_attrs = {}
self.render_helper.update_url_qs = update_url_qs
return format_html(icons)
def render_health(self, record):
return format_html(
self.render_helper.render_list_coherent(
items=record.get_health_icons(), safe=True))
def render_contact(self, value):
return Link(url=value.detail_view_uri, content=value).render(safe=True)
def render_service__created_by(self, value):
return Link(url=value.get_absolute_url(),
content=value).render(safe=True)
def render_service__published_for(self, value):
return Link(url=value.detail_view_uri, content=value).render(safe=True)
def order_layers(self, queryset, is_descending):
queryset = queryset.annotate(
count=Count("service__child_services")).order_by(
("-" if is_descending else "") + "count")
return queryset, True
def order_wfs_featuretypes(self, queryset, is_descending):
queryset = queryset.annotate(count=Count(
"service__featuretypes")).order_by(("-" if is_descending else "") +
"count")
return queryset, True
def order_status(self, queryset, is_descending):
is_descending_str = "-" if is_descending else ""
queryset = queryset.order_by(
is_descending_str + "is_active",
is_descending_str + "is_secured",
is_descending_str + "external_authentication",
)
return queryset, True
def order_health(self, queryset, is_descending):
# TODO:
return queryset, True
class OgcServiceTable(tables.Table):
bs4helper = None
layers = tables.Column(verbose_name=_('Layers'),
empty_values=[],
accessor='service__child_services__count')
featuretypes = tables.Column(verbose_name=_('Featuretypes'),
empty_values=[],
accessor='service__featuretypes__count')
parent_service = tables.Column(
verbose_name=_('Parent service'),
empty_values=[],
accessor='service__parent_service__metadata')
status = tables.Column(verbose_name=_('Status'),
empty_values=[],
attrs={"td": {
"style": "white-space:nowrap;"
}})
health = tables.Column(
verbose_name=_('Health'),
empty_values=[],
)
harvest_results = tables.Column(
verbose_name=_('Last harvest'),
empty_values=[],
)
collected_harvest_records = tables.Column(
verbose_name=_('Collected harvest records'),
empty_values=[],
accessor='harvest_results')
actions = tables.Column(verbose_name=_('Actions'),
empty_values=[],
orderable=False,
attrs={"td": {
"style": "white-space:nowrap;"
}})
class Meta:
model = Metadata
fields = ('title', 'layers', 'featuretypes', 'parent_service',
'status', 'health', 'service__service_type__version',
'harvest_results', 'collected_harvest_records', 'contact',
'service__created_by__mrmapgroup', 'service__published_for',
'created', 'actions')
template_name = "skeletons/django_tables2_bootstrap4_custom.html"
prefix = 'ogc-service-table'
def before_render(self, request):
self.render_helper = RenderHelper(user_permissions=list(
filter(None, request.user.get_all_permissions())))
def render_title(self, record, value):
return Link(url=record.detail_view_uri,
content=value).render(safe=True)
def render_harvest_results(self, record, value):
last_harvest_result = value.filter(
metadata=record).order_by("-created").first()
return last_harvest_result.timestamp_start if last_harvest_result is not None else _(
'Never')
def render_collected_harvest_records(self, record, value):
last_harvest_result = value.filter(
metadata=record).order_by("-created").first()
return last_harvest_result.number_results if last_harvest_result is not None else '-'
# todo
def render_wms_validation(self, record):
passed = None
try:
check_run = ConformityCheckRun.objects.get_latest_check(record)
passed = check_run.passed
except ConformityCheckRun.DoesNotExist:
pass
return self.get_validation_icons(passed=passed)
def render_parent_service(self, value):
return Link(url=value.detail_view_uri, content=value).render(safe=True)
def render_status(self, record):
self.render_helper.update_attrs = {'class': ['mr-1']}
update_url_qs = self.render_helper.update_url_qs
self.render_helper.update_url_qs = {}
icons = self.render_helper.render_list_coherent(
items=record.get_status_icons(), safe=True)
self.render_helper.update_attrs = {}
self.render_helper.update_url_qs = update_url_qs
return format_html(icons)
def render_health(self, record):
return format_html(
self.render_helper.render_list_coherent(
items=record.get_health_icons(), safe=True))
def render_contact(self, value):
return Link(url=value.detail_view_uri, content=value).render(safe=True)
def render_service__created_by(self, value):
return Link(url=value.get_absolute_url(),
content=value).render(safe=True)
def render_service__published_for(self, value):
return Link(url=value.detail_view_uri, content=value).render(safe=True)
def render_actions(self, record):
self.render_helper.update_attrs = {"class": ["btn-sm", "mr-1"]}
renderd_actions = self.render_helper.render_list_coherent(
items=record.get_actions())
self.render_helper.update_attrs = None
return format_html(renderd_actions)
def order_layers(self, queryset, is_descending):
queryset = queryset.annotate(
count=Count("service__child_services")).order_by(
("-" if is_descending else "") + "count")
return queryset, True
def order_wfs_featuretypes(self, queryset, is_descending):
queryset = queryset.annotate(count=Count(
"service__featuretypes")).order_by(("-" if is_descending else "") +
"count")
return queryset, True
def order_status(self, queryset, is_descending):
is_descending_str = "-" if is_descending else ""
queryset = queryset.order_by(
is_descending_str + "is_active",
is_descending_str + "is_secured",
is_descending_str + "external_authentication",
)
return queryset, True
def order_health(self, queryset, is_descending):
# TODO:
return queryset, True
