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)