def __init__(self, *args, **kwargs):
super(DatasetIdentificationForm, self).__init__(has_autocomplete_fields=True,
*args,
**kwargs)
self.fields['additional_related_objects'].queryset = user_helper.get_user(self.request).get_metadatas_as_qs(
type=MetadataEnum.DATASET, inverse_match=True)
self.fields['reference_system'].queryset = ReferenceSystem.objects.all()
user = user_helper.get_user(request=kwargs.pop("request"))
user_groups = user.groups.filter(mrmapgroup__is_public_group=False)
self.fields["created_by"].queryset = user_groups
self.fields["created_by"].initial = user_groups.first()
if self.instance_id:
metadata = Metadata.objects.get(pk=self.instance_id)
dataset = Dataset.objects.get(pk=metadata.dataset.id)
self.fields['title'].initial = metadata.title
self.fields['abstract'].initial = metadata.abstract
self.fields['reference_system'].initial = metadata.reference_system.all()
self.fields['date_stamp'].initial = dataset.date_stamp
self.fields['language_code'].initial = dataset.language_code
self.fields['character_set_code'].initial = dataset.character_set_code
self.fields['additional_related_objects'].queryset = self.fields['additional_related_objects'].queryset.exclude(id=self.instance_id)
exclusions = {'to_metadatas__origin': ResourceOriginEnum.CAPABILITIES.value}
related_metadatas = metadata.get_related_metadatas(exclusions=exclusions)
self.fields['additional_related_objects'].initial = related_metadatas
def menu_view(request: HttpRequest):
""" The API menu view where settings for the remote access can be set.
Args:
request (HttpRequest): The incoming request
Returns:
rendered view
"""
template = "views/api_menu.html"
token_form = TokenForm(request.POST)
user = user_helper.get_user(request)
if not user.is_authenticated:
return redirect("login")
# Get user token
try:
token = Token.objects.get(user=user)
except ObjectDoesNotExist:
# User has no token yet
token = None
if token is not None:
token_form = TokenForm(instance=token)
token_form.action_url = reverse("api:generate-token")
params = {
"form": token_form,
}
default_context = DefaultContext(request, params, user)
return render(request, template, default_context.get_context())
def wrap(request, *args, **kwargs):
user = user_helper.get_user(request=request)
try:
md = Metadata.objects.get(id=kwargs["metadata_id"])
except ObjectDoesNotExist:
return HttpResponse(status=404, content=SERVICE_NOT_FOUND)
logged_user = None
if user.is_authenticated:
logged_user = user
uri = request.path
post_body = {}
if request.method.lower() == "post":
post_body = request.POST.dict()
elif request.method.lower() == "get":
uri += "?" + request.META.get("QUERY_STRING")
post_body = json.dumps(post_body)
proxy_log = None
if md.use_proxy_uri and md.log_proxy_access:
proxy_log = ProxyLog(metadata=md,
uri=uri,
operation=get_dict_value_insensitive(
request.GET.dict(), "request"),
post_body=post_body,
user=logged_user)
proxy_log.save()
return function(request=request, proxy_log=proxy_log, *args, **kwargs)
def active_state(self, request, pk=None):
""" Activates a service via remote access
Args:
request: The incoming request
pk: The service id
Returns:
Response
"""
user = user_helper.get_user(request)
parameter_name = "active"
new_status = request.POST.dict().get(parameter_name, None)
new_status = utils.resolve_boolean_attribute_val(new_status)
response = APIResponse()
if new_status is None or not isinstance(new_status, bool):
response.data["msg"] = PARAMETER_ERROR.format(parameter_name)
return Response(data=response.data, status=500)
try:
md = Metadata.objects.get(service__id=pk)
response.data["oldStatus"] = md.is_active
md.is_active = new_status
md.save()
response.data["newStatus"] = md.is_active
response.data["success"] = True
return Response(data=response.data, status=200)
except ObjectDoesNotExist:
response.data["msg"] = SERVICE_NOT_FOUND
return Response(data=response.data, status=404)
def has_permission(self, request, view):
if view.action == "destroy":
user = user_helper.get_user(request)
needed_perm = PermissionEnum.CAN_REMOVE_RESOURCE
has_perm = user.has_perm(perm=needed_perm)
return has_perm
else:
return True
def has_permission(self, request, view):
if view.action == "active_state":
user = user_helper.get_user(request)
needed_perm = PermissionEnum.CAN_ACTIVATE_RESOURCE
has_perm = user.has_perm(perm=needed_perm)
return has_perm
else:
return True
def new_pending_update_service(request: HttpRequest, metadata_id):
""" Compare old service with new service and collect differences
Args:
request: The incoming request
metadata_id: The service id
Returns:
A rendered view
"""
current_service = get_object_or_404(Service, metadata__id=metadata_id)
user = user_helper.get_user(request)
form = UpdateServiceCheckForm(
data=request.POST or None,
request=request,
reverse_lookup='resource:new-pending-update',
reverse_args=[
metadata_id,
],
# ToDo: after refactoring of all forms is done, show_modal can be removed
show_modal=True,
current_service=current_service,
requesting_user=user,
form_title=_l(
f'Update service: <strong>{current_service.metadata.title} [{current_service.metadata.id}]</strong>'
))
if request.method == 'GET':
return form.render_view()
if request.method == 'POST':
# Check if update form is valid
if form.is_valid():
# Create db model from new service information (no persisting, yet)
new_service = service_helper.create_service(
service_type=form.url_dict.get("service"),
version=service_helper.resolve_version_enum(
form.url_dict.get("version")),
base_uri=form.url_dict.get("base_uri"),
user=user,
register_group=current_service.created_by,
is_update_candidate_for=current_service,
)
new_service.created_by_user = user
new_service.keep_custom_md = form.cleaned_data['keep_custom_md']
new_service.metadata.is_update_candidate_for = current_service.metadata
new_service.metadata.created_by_user = user
new_service.save()
return HttpResponseRedirect(reverse("resource:pending-update",
args=(metadata_id, )),
status=303)
else:
form.fade_modal = False
return form.render_view(status_code=422)
return HttpResponseRedirect(reverse(request.GET.get('current-view', None),
args=(metadata_id, )),
status=303)
def process_new_publisher_request(self):
user = user_helper.get_user(self.request)
publish_request_obj = PublishRequest()
publish_request_obj.organization = self.organization
publish_request_obj.message = self.cleaned_data["request_msg"]
publish_request_obj.group = self.cleaned_data["group"]
publish_request_obj.activation_until = timezone.now() + timezone.timedelta(
hours=PUBLISH_REQUEST_ACTIVATION_TIME_WINDOW)
publish_request_obj.created_by = user
publish_request_obj.save()
# create pending publish request for organization!
messages.success(self.request, message=PUBLISH_REQUEST_SENT)
def validate(request, metadata_id: str):
config_id = request.GET.get('config_id', None)
current_view = request.GET.get(CURRENT_VIEW_QUERY_Param, None)
current_view_arg = request.GET.get(CURRENT_VIEW_ARG_QUERY_Param, None)
if config_id is None:
return HttpResponse('Parameter config_id is missing',
status=status.HTTP_400_BAD_REQUEST)
metadata = get_object_or_404(Metadata, pk=metadata_id)
if not metadata.is_active:
return HttpResponse('Resource to be validated is not active',
status=status.HTTP_400_BAD_REQUEST)
user = user_helper.get_user(request)
group = metadata.created_by
success_callback = complete_validation.s(group_id=group.id,
user_id=user.id)
error_callback = complete_validation_error.s(group_id=group.id,
user_id=user.id,
config_id=config_id,
metadata_id=metadata.id)
pending_task = run_quality_check.apply_async(args=(config_id, metadata_id),
link=success_callback,
link_error=error_callback)
pending_task_db = PendingTask()
pending_task_db.created_by = group
pending_task_db.task_id = pending_task.id
pending_task_db.description = json.dumps({
"status": f'Validating {metadata.title}',
"service": metadata.title,
"phase": "Validating",
})
pending_task_db.progress = 10
pending_task_db.type = PendingTaskEnum.VALIDATE.value
pending_task_db.save()
if current_view is not None:
if current_view_arg is not None:
return HttpResponseRedirect(reverse(current_view,
args=(current_view_arg, )),
status=303)
else:
return HttpResponseRedirect(reverse(current_view), status=303)
return HttpResponse(status=status.HTTP_200_OK)
def __init__(self,
request=None,
filter_set_class=None,
queryset=None,
query_filter=None,
query_class=None,
current_view=None,
param_lead='mr-map-t',
*args,
**kwargs):
# Generate a random id for html template
self.table_id = str(uuid.uuid4())
self.request = request
self.filter_set_class = filter_set_class
self.queryset = queryset
self.user = user_helper.get_user(request)
self.current_view = current_view
self.param_lead = param_lead
self.permission_lookup = {}
# He we set the data kw dynamic by the query_class and query_filter,
# so we don't need to set the data kw in every view again and again
# ToDo: it's a little bit messy... refactor this if/else
if queryset is not None:
if filter_set_class:
self._configure_filter_set()
kwargs['data'] = self.filter_set.qs
else:
kwargs['data'] = queryset
elif query_class:
if query_filter:
if filter_set_class:
self._configure_filter_set(queryset=query_class.objects.filter(query_filter))
kwargs['data'] = self.filter_set.qs
else:
data = query_class.objects.filter(query_filter)
else:
if filter_set_class:
self._configure_filter_set(queryset=query_class.objects.all())
kwargs['data'] = self.filter_set.qs
else:
data = query_class.objects.all()
kwargs['data'] = data
super(MrMapTable, self).__init__(template_name=DJANGO_TABLES2_BOOTSTRAP4_CUSTOM_TEMPLATE, *args, **kwargs)
self._configure_pagination()
def create(self, validated_data, request: HttpRequest = None):
""" Creates a new service
Starts the regular registration process
Args:
validated_data (dict): The validated data from a POST request
Returns:
pending_task (PendingTask) or None
"""
# Writing of .get("xy", None) or None makes sure that empty strings will be mapped to None
user = user_helper.get_user(request=request)
get_capabilities_uri = validated_data.get("uri", None) or None
registering_with_group = validated_data.get("group", None) or None
registering_for_org = validated_data.get("for-org", None) or None
has_ext_auth = validated_data.get("ext-auth", False) or False
ext_auth_username = validated_data.get("ext-username", None) or None
ext_auth_password = validated_data.get("ext-password", None) or None
ext_auth_type = validated_data.get("ext-auth-type", None) or None
# Split uri in components as it is done with RegisterNewServiceWizardPage1
url_dict = service_helper.split_service_uri(get_capabilities_uri)
ogc_request = url_dict["request"]
ogc_service = url_dict["service"].value
ogc_version = url_dict["version"]
uri = url_dict["base_uri"]
init_data = {
"ogc_request": ogc_request,
"ogc_service": ogc_service,
"ogc_version": ogc_version,
"uri": uri,
"registering_with_group": registering_with_group,
"registering_for_other_organization": registering_for_org,
"service_needs_authentication": has_ext_auth,
"username": ext_auth_username,
"password": ext_auth_password,
"authentication_type": ext_auth_type,
}
# Use RegisterNewResourceWizardPage2 workflow as for frontend registration
form = RegisterNewResourceWizardPage2(data=init_data, request=request)
if form.is_valid():
pending_task = service_helper.create_new_service(form, user)
return pending_task
return None
def __init__(self, *args, **kwargs):
user = user_helper.get_user(kwargs.get("request"))
user_groups = user.groups.all()
if 'instance_id' in kwargs and kwargs['instance_id'] is not None:
metadata = Metadata.objects.get(id=kwargs['instance_id'])
init_organization = Organization.objects.filter(
id=metadata.contact.id)
organizations = Organization.objects.filter(
Q(is_auto_generated=False) & Q(publishers__in=user_groups)
| Q(id=user.organization.id)) | init_organization
else:
organizations = Organization.objects.filter(
Q(is_auto_generated=False) & Q(publishers__in=user_groups)
| Q(id=user.organization.id))
super(DatasetResponsiblePartyForm, self).__init__(*args, **kwargs)
self.fields['organization'].queryset = organizations
def validate(request, metadata_id: str):
config_id = request.GET.get('config_id', None)
current_view = request.GET.get(CURRENT_VIEW_QUERY_Param, None)
current_view_arg = request.GET.get(CURRENT_VIEW_ARG_QUERY_Param, None)
if config_id is None:
return HttpResponse('Parameter config_id is missing',
status=status.HTTP_400_BAD_REQUEST)
metadata = get_object_or_404(Metadata, pk=metadata_id)
if not metadata.is_active:
return HttpResponse('Resource to be validated is not active',
status=status.HTTP_400_BAD_REQUEST)
user = user_helper.get_user(request)
group = metadata.created_by
success_callback = complete_validation.s(group_id=group.id,
user_id=user.id)
error_callback = complete_validation_error.s(group_id=group.id,
user_id=user.id,
config_id=config_id,
metadata_id=metadata.id)
pending_task = run_quality_check.apply_async(args=(config_id, metadata_id),
link=success_callback,
link_error=error_callback)
if current_task:
current_task.update_state(state=states.STARTED,
meta={
"current": 10,
"phase": f"Validating {metadata.title}",
})
if current_view is not None:
if current_view_arg is not None:
return HttpResponseRedirect(reverse(current_view,
args=(current_view_arg, )),
status=303)
else:
return HttpResponseRedirect(reverse(current_view), status=303)
return HttpResponse(status=status.HTTP_200_OK)
def get_queryset(self):
""" Getter for the matching metadatas
Returns:
records (QuerySet): The matched records
"""
user = get_user(self.request)
if user is None:
return None
records = user.get_metadatas_as_qs(type=MetadataEnum.DATASET,
inverse_match=True)
query = ""
if self.q:
# There are filtering parameters!
query = self.q
records = records.filter(
Q(title__icontains=query) | Q(id__icontains=query))
return records
def generate_token(request: HttpRequest):
""" Generates a token for the user.
Returns after finished work back to the menu page
Args:
request (HttpRequest): The incoming request
Returns:
A redirect to a view
"""
if request.method == "POST":
user = user_helper.get_user(request)
# Get user token
try:
token = Token.objects.get(user=user)
except ObjectDoesNotExist:
# User has no token yet
token = None
# Remove the given key.
# Otherwise the is_valid() would fail, since the key for this user could already exists.
# We are only interested in the csrf token validation.
post_dict = request.POST.dict()
post_dict["key"] = ""
token_form = TokenForm(post_dict)
if not token_form.is_valid():
return HttpResponse(status=403)
# Generate new access token, old token can not be reused, must be deleted
if token is not None:
token.delete()
token = Token(user=user)
token.save()
# Redirect user directly to the same page. Why?
# This way, we make sure the user does not re-generate another token accidentally by pressing F5 or reload,
# or whatever. We force the GET way.
return redirect("api:menu")
def get_queryset(self):
""" Getter for the matching metadatas
Returns:
records (QuerySet): The matched records
"""
user = get_user(self.request)
if user is None:
return None
records = Metadata.objects.filter(
metadata_type=MetadataEnum.SERVICE.value,
is_active=True,
)
query = ""
if self.q:
# There are filtering parameters!
query = self.q
records = records.filter(
Q(title__icontains=query) | Q(id__icontains=query))
return records
def dismiss_pending_update_service(request: HttpRequest, metadata_id):
user = user_helper.get_user(request)
current_service = get_object_or_404(Service, metadata__id=metadata_id)
new_service = get_object_or_404(Service,
is_update_candidate_for=current_service)
if request.method == 'POST':
if new_service.created_by_user == user:
new_service.delete()
messages.success(request,
_l("Pending update successfully dismissed."))
else:
messages.error(
request,
_l("You are not the owner of this pending update. Rejected!"))
return HttpResponseRedirect(reverse(
"resource:detail", args=(current_service.metadata.id, )),
status=303)
return HttpResponseRedirect(reverse("resource:pending-update",
args=(current_service.metadata.id, )),
status=303)
def metadata_subscription_new(request: HttpRequest, metadata_id: str):
""" Creates a new subscription for a metadat without a form
Args:
request (HttpRequest): The incoming request
metadata_id (str): The id of the metadata which shall be subscribed
Returns:
A rendered view
"""
md = get_object_or_404(Metadata, id=metadata_id)
user = user_helper.get_user(request)
subscription_created = Subscription.objects.get_or_create(
metadata=md,
user=user,
)[1]
if subscription_created:
messages.success(request,
SUBSCRIPTION_SUCCESSFULLY_CREATED.format(md.title))
else:
messages.info(request,
SUBSCRIPTION_ALREADY_EXISTS_TEMPLATE.format(md.title))
return redirect("subscription-index")
def pending_update_service(
request: HttpRequest,
metadata_id,
update_params: dict = None,
status_code: int = 200,
):
template = "views/service_update.html"
user = user_helper.get_user(request)
current_service = get_object_or_404(Service, metadata__id=metadata_id)
try:
new_service = Service.objects.get(
is_update_candidate_for=current_service)
except ObjectDoesNotExist:
messages.error(request, _l("No updatecandidate was found."))
# ToDo: make 7 dynamic
messages.info(request,
_l("Update candidates will be deleted after 7 days."))
return HttpResponseRedirect(reverse("resource:detail",
args=(metadata_id, )),
status=303)
if current_service.is_service_type(OGCServiceEnum.WMS):
current_service.root_layer = Layer.objects.get(
parent_service=current_service, parent=None)
new_service.root_layer = Layer.objects.get(parent_service=new_service,
parent=None)
# Collect differences
comparator = ServiceComparator(service_a=new_service,
service_b=current_service)
diff = comparator.compare_services()
diff_elements = diff.get("layers", None) or diff.get("feature_types", {})
update_confirmation_form = UpdateOldToNewElementsForm(
new_elements=diff_elements.get("new"),
removed_elements=diff_elements.get("removed"),
current_service=current_service,
)
update_confirmation_form.action_url = reverse("resource:run-update",
args=[metadata_id])
updated_elements_md = []
for element in diff_elements.get("updated"):
updated_elements_md.append(element.metadata)
removed_elements_md = []
for element in diff_elements.get("removed"):
removed_elements_md.append(element.metadata)
updated_elements_table = UpdateServiceElements(
request=request,
queryset=updated_elements_md,
current_view="resource:dismiss-pending-update",
order_by_field='updated',
)
removed_elements_table = UpdateServiceElements(
request=request,
queryset=removed_elements_md,
current_view="resource:dismiss-pending-update",
order_by_field='removed',
)
params = {
"current_service": current_service,
"update_service": new_service,
"diff_elements": diff_elements,
"updated_elements_table": updated_elements_table,
"removed_elements_table": removed_elements_table,
"update_confirmation_form": update_confirmation_form,
"new_elements_per_page": request.GET.get('new_elements_per_page', 5),
}
if update_params:
params.update(update_params)
return render(request=request,
template_name=template,
context=params,
status=status_code)
