def __init__(self, *args, **kwargs): feature_type = kwargs.pop('feature_type') user = kwargs.pop('user', None) super().__init__(*args, **kwargs) project = feature_type.project # Status choices initial = 'draft' choices = tuple(x for x in Feature.STATUS_CHOICES) if not project.moderation: choices = tuple(x for x in Feature.STATUS_CHOICES if x[0] != 'pending') initial = 'published' if not self.instance else self.instance.status if project.moderation and not Authorization.has_permission(user, 'can_publish_feature', project): choices = tuple(x for x in Feature.STATUS_CHOICES if x[0] in ['draft', 'pending']) initial = 'pending' if project.moderation and Authorization.has_permission(user, 'can_publish_feature', project): choices = tuple(x for x in Feature.STATUS_CHOICES if x[0] in ['draft', 'published', 'archived']) initial = 'draft' self.fields['status'] = forms.ChoiceField( choices=choices, initial=initial, label='Statut' )
def get(self, request, slug, feature_type_slug, feature_id): user = request.user feature = self.get_object() project = feature.project layers = Layer.objects.filter(project=project) serialized_layers = LayerSerializer(layers, many=True) linked_features = FeatureLink.objects.filter( feature_from=feature.feature_id ) serialized_link = FeatureLinkSerializer(linked_features, many=True) events = Event.objects.filter(feature_id=feature.feature_id).order_by('created_on') serialized_events = EventSerializer(events, many=True) context = { 'feature': feature, 'feature_data': feature.custom_fields_as_list, 'feature_types': FeatureType.objects.filter(project=project), 'feature_type': feature.feature_type, 'linked_features': serialized_link.data, 'project': project, 'permissions': Authorization.all_permissions(user, project, feature), 'comments': Comment.objects.filter(project=project, feature_id=feature.feature_id), 'attachments': Attachment.objects.filter( project=project, feature_id=feature.feature_id, object_type='feature'), 'events': serialized_events.data, 'comment_form': CommentForm(), 'layers': serialized_layers.data, } return render(request, 'geocontrib/feature/feature_detail.html', context)
def get_context_data(self, **kwargs): user = self.request.user project = self.get_object() permissions = Authorization.all_permissions(user, project) # On filtre les signalements selon leur statut et l'utilisateur courant features = Feature.handy.availables( user=user, project=project).order_by('-created_on') # On filtre les commentaire selon les signalements visibles last_comments = Comment.objects.filter( project=project, feature_id__in=[feat.feature_id for feat in features]).order_by('-created_on')[0:5] serialized_comments = CommentSerializer(last_comments, many=True).data serilized_projects = ProjectDetailedSerializer(project).data context = super().get_context_data(**kwargs) context['project'] = serilized_projects context['title'] = project.title context['user'] = user context['last_comments'] = serialized_comments context['last_features'] = features[0:5] context['features'] = features context['permissions'] = permissions context['feature_types'] = project.featuretype_set.all() context['is_suscriber'] = Subscription.is_suscriber(user, project) return context
def post(self, request, slug): user = self.request.user project = self.get_object() permissions = Authorization.all_permissions(user, project) formset = ProjectBaseMapInlineFormset(data=request.POST or None, instance=project) if formset.is_valid(): formset.save() messages.success(request, 'Enregistrement effectué.') return redirect('geocontrib:project_mapping', slug=project.slug) else: logger.debug(formset.errors) messages.error(request, "L'édition des fonds cartographiques a échoué. ") formset = ProjectBaseMapInlineFormset(data=request.POST or None, instance=project) context = { **self.get_context_data(), **{ 'project': project, 'permissions': permissions, 'formset': formset, 'title': project.title, } } return render(request, 'geocontrib/project/project_mapping.html', context)
def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) project = self.get_object() user = self.request.user permissions = Authorization.all_permissions(user, project) last_comments = Comment.objects.filter( project=project ).order_by('-created_on')[0:5] serialized_comments = CommentSerializer(last_comments, many=True).data features = Feature.objects.filter( project=project ).order_by('-created_on') serilized_projects = ProjectDetailedSerializer(project).data context['project'] = serilized_projects context['user'] = user context['last_comments'] = serialized_comments context['last_features'] = features[0:5] context['features'] = features context['permissions'] = permissions context['feature_types'] = project.featuretype_set.all() context['is_suscriber'] = Subscription.is_suscriber(user, project) # EDC layers = Layer.objects.filter(project=project) serialized_layers = LayerSerializer(layers, many=True) context['layers'] = serialized_layers.data return context
def custom_contexts(request): try: user_level_projects = Authorization.get_user_level_projects( request.user) except Exception: user_level_projects = {} logger.exception('Cannot retrieve user level project') return { 'APPLICATION_NAME': settings.APPLICATION_NAME, 'LOGO_PATH': settings.LOGO_PATH, 'APPLICATION_ABSTRACT': settings.APPLICATION_ABSTRACT, 'FAVICON_PATH': settings.FAVICON_PATH, 'IMAGE_FORMAT': settings.IMAGE_FORMAT, 'FILE_MAX_SIZE': settings.FILE_MAX_SIZE, 'USER_LEVEL_PROJECTS': user_level_projects, 'SERVICE': settings.DEFAULT_BASE_MAP.get('SERVICE'), 'OPTIONS': settings.DEFAULT_BASE_MAP.get('OPTIONS'), 'DEFAULT_MAP_VIEW': settings.DEFAULT_MAP_VIEW, 'GEOCODER_PROVIDERS': settings.GEOCODER_PROVIDERS, 'SELECTED_GEOCODER_PROVIDER': settings.SELECTED_GEOCODER.get('PROVIDER'), 'SSO_SETTED': sso_setted(request), 'LOGIN_URL': login_url(), }
def get(self, request, slug, feature_type_slug, feature_id): user = request.user feature = self.get_object() project = feature.project linked_features = FeatureLink.handy.related(feature.feature_id) serialized_link = FeatureLinkSerializer(linked_features, many=True) events = Event.objects.filter( feature_id=feature.feature_id).order_by('created_on') serialized_events = EventSerializer(events, many=True) context = self.get_context_data(feature_id=feature_id) context['feature'] = feature context['feature_data'] = feature.custom_fields_as_list context['linked_features'] = serialized_link.data context['permissions'] = Authorization.all_permissions( user, project, feature) context['events'] = serialized_events.data context['attachments'] = Attachment.objects.filter( project=project, feature_id=feature.feature_id, object_type='feature') context['comment_form'] = CommentForm() context['project'] = project return render(request, 'geocontrib/feature/feature_detail.html', context)
def get(self, request, slug, feature_type_slug): feature_type = self.get_object() form = FeatureTypeModelForm(instance=feature_type) formset = self.CustomFieldsFormSet(queryset=CustomField.objects.filter( feature_type=feature_type)) project = feature_type.project user = request.user features = Feature.handy.availables(user, project).filter( feature_type=feature_type).order_by('-updated_on')[:5] structure = FeatureTypeSerializer(feature_type, context={'request': request}) context = { 'feature_type': feature_type, 'permissions': Authorization.all_permissions(user, project), 'features': features, 'project': project, 'structure': structure.data, 'form': form, 'formset': formset, 'title': feature_type.title, } return render(request, 'geocontrib/feature_type/feature_type_edit.html', context)
def test_func(self): return True user = self.request.user feature_type = self.get_object() project = feature_type.project return Authorization.has_permission(user, 'can_create_feature', project)
def get(self, request, slug): project = self.get_object() user = request.user slug = request.GET.get('create_from') feature_type = FeatureType.objects.filter(slug=slug).first() if feature_type and isinstance(feature_type, FeatureType): initial = model_to_dict(feature_type) if initial.get('title'): initial.update({ 'title': "{} (Copie {})".format( initial['title'], timezone.now().strftime("%d/%m/%Y %H:%M")) }) form = FeatureTypeModelForm(initial=initial) formset = self.CustomFieldsFormSet( queryset=CustomField.objects.filter( feature_type=feature_type), ) else: form = FeatureTypeModelForm() formset = self.CustomFieldsFormSet( queryset=CustomField.objects.none()) context = { 'form': form, 'formset': formset, 'permissions': Authorization.all_permissions(user, project), 'feature_types': project.featuretype_set.all(), 'project': project, 'title': "Création d'un type de signalement", } return render(request, 'geocontrib/feature_type/feature_type_create.html', context)
def get(self, request, slug, *args, **kwargs): project = self.get_object() user = request.user layers = Layer.objects.filter(project=project).order_by('order') serialized_layers = LayerSerializer(layers, many=True) permissions = Authorization.all_permissions(user, project) feature_types = FeatureType.objects.filter(project=project) features = Feature.handy.availables(user, project).order_by('-updated_on') filters = {} filters['status'] = request.GET.get('status', None) filters['feature_type__slug'] = request.GET.get('feature_type', None) filters['title__icontains'] = request.GET.get('title', None) if filters: filters = {k: v for k, v in filters.items() if v is not None} features = features.filter(**filters) context = { 'features': features, 'feature_types': feature_types, 'layers': serialized_layers.data, 'project': project, 'permissions': permissions, 'status_choices': Feature.STATUS_CHOICES, } return render(request, 'geocontrib/feature/feature_list.html', context)
def post(self, request, slug): user = request.user form = FeatureTypeModelForm(request.POST or None) project = self.get_object() formset = self.CustomFieldsFormSet(request.POST or None) if form.is_valid() and formset.is_valid(): feature_type = form.save(commit=False) feature_type.project = project feature_type.save() for data in formset.cleaned_data: if not data.get("DELETE"): CustomField.objects.create( feature_type=feature_type, position=data.get("position"), label=data.get("label"), name=data.get("name"), field_type=data.get("field_type"), options=data.get("options"), ) return redirect('geocontrib:project', slug=project.slug) else: context = { 'form': form, 'formset': formset, 'permissions': Authorization.all_permissions(user, project), 'feature_types': project.featuretype_set.all(), 'project': project, 'title': "Création d'un type de signalement", } return render(request, 'geocontrib/feature_type/feature_type_create.html', context)
def get(self, request): try: user_level_projects = Authorization.get_user_level_projects( request.user) except Exception: user_level_projects = {} return Response(data=user_level_projects, status=200)
def get(self, request, slug, feature_type_slug, feature_id): user = request.user feature = self.get_object() project = feature.project feature_type = feature.feature_type layers = Layer.objects.filter(project=project) serialized_layers = LayerSerializer(layers, many=True) extra = CustomField.objects.filter(feature_type=feature_type) availables_features = Feature.objects.filter( project=project, ).exclude(feature_id=feature.feature_id) feature_form = FeatureBaseForm( instance=feature, feature_type=feature_type, user=user) extra_form = FeatureExtraForm(feature=feature, extra=extra) linked_features = FeatureLink.objects.filter( feature_from=feature.feature_id ).annotate( feature_id=F('feature_to')).values('relation_type', 'feature_id') linked_formset = self.LinkedFormset( form_kwargs={'feature_type': feature_type, 'feature': feature}, prefix='linked', initial=linked_features, queryset=FeatureLink.objects.filter(feature_from=feature.feature_id)) attachments = Attachment.objects.filter( project=project, feature_id=feature.feature_id, object_type='feature' ) attachment_formset = self.AttachmentFormset( prefix='attachment', initial=attachments.values(), queryset=attachments ) context = { 'feature': feature, 'features': Feature.handy.availables(user, project).order_by('updated_on'), 'feature_data': feature.custom_fields_as_list, 'feature_types': FeatureType.objects.filter(project=project), 'feature_type': feature.feature_type, 'project': project, 'permissions': Authorization.all_permissions(user, project, feature), 'feature_form': feature_form, 'extra_form': extra_form, 'availables_features': availables_features, 'linked_formset': linked_formset, 'attachment_formset': attachment_formset, 'attachments': attachments, 'action': 'update', 'layers': serialized_layers.data } return render(request, 'geocontrib/feature/feature_edit.html', context)
def post(self, request, slug, feature_type_slug): user = request.user feature_type = self.get_object() form = FeatureTypeModelForm(request.POST or None, instance=feature_type) formset = self.CustomFieldsFormSet(data=request.POST or None) if form.is_valid() and formset.is_valid(): updated_feature_type = form.save() for data in formset.cleaned_data: custom_field = data.pop('id', None) if custom_field and data.get('DELETE'): custom_field.delete() if custom_field and not data.get('DELETE'): for key in [ 'name', 'field_type', 'position', 'label', 'options' ]: setattr(custom_field, key, data.get(key)) custom_field.save() if not custom_field and not data.get('DELETE'): CustomField.objects.create( name=data.get('name'), field_type=data.get('field_type'), position=data.get('position'), label=data.get('label'), options=data.get('options'), feature_type=updated_feature_type, ) return redirect('geocontrib:project', slug=feature_type.project.slug) else: logger.error(form.errors) logger.error(formset.errors) messages.error( request, "Erreur lors de l'édition du type de signalement. ") context = { 'form': form, 'formset': formset, 'permissions': Authorization.all_permissions(user, feature_type.project), 'project': feature_type.project, 'feature_type': feature_type, 'title': feature_type.title } return render(request, 'geocontrib/feature_type/feature_type_edit.html', context)
def __init__(self, *args, **kwargs): feature_type = kwargs.pop('feature_type') user = kwargs.pop('user', None) super().__init__(*args, **kwargs) project = feature_type.project # Status choices initial = 'draft' choices = tuple(x for x in Feature.STATUS_CHOICES) if not project.moderation: choices = tuple(x for x in Feature.STATUS_CHOICES if x[0] != 'pending') initial = 'published' if not self.instance else self.instance.status if project.moderation and not Authorization.has_permission( user, 'can_publish_feature', project): choices = tuple(x for x in Feature.STATUS_CHOICES if x[0] in ['draft', 'pending']) initial = 'pending' if project.moderation and Authorization.has_permission( user, 'can_publish_feature', project): choices = tuple(x for x in Feature.STATUS_CHOICES if x[0] in ['draft', 'published', 'archived']) initial = 'draft' self.fields['status'] = forms.ChoiceField(choices=choices, initial=initial, label='Statut') # TODO: factoriser les attributs de champs geom if feature_type.geom_type == "point": self.fields['geom'] = forms.PointField(label="Localisation", required=True, srid=4326) if feature_type.geom_type == "linestring": self.fields['geom'] = forms.LineStringField(label="Localisation", required=True, srid=4326) if feature_type.geom_type == "polygon": self.fields['geom'] = forms.PolygonField(label="Localisation", required=True, srid=4326)
def test_func(self): user = self.request.user feature_type = self.get_object() project = feature_type.project # On interdit l'édition d'un feature_type si des signalements ont déja été crée if Feature.objects.filter(feature_type=feature_type).exists(): return False return Authorization.has_permission(user, 'can_create_feature_type', project)
def filter_queryset(self, request, queryset, view): user_level_projects = Authorization.get_user_level_projects_ids( request.user) if request.query_params.get('accessible'): for i, c in enumerate(queryset): if (c.access_level_pub_feature.rank > user_level_projects[c.slug]): queryset = queryset.exclude(slug=c.slug) return queryset
def filter_queryset(self, request, queryset, view): user_level_projects = Authorization.get_user_level_projects_ids( request.user) user_access_level = request.query_params.get('user_access_level') if user_access_level: requested_user_access_level_projects = dict( (k, v) for k, v in user_level_projects.items() if v == int(user_access_level)) queryset = queryset.filter( slug__in=requested_user_access_level_projects.keys()) return queryset
def get(self, request): data = {} user = request.user # data['user'] = user # on liste les droits de l'utilisateur pour chaque projet data['permissions'] = {} data['rank'] = {} for project in Project.objects.all(): data['permissions'][project.slug] = Authorization.has_permission( user, 'can_view_project', project) try: rank = Authorization.objects.get(project=project, user=user).level rank = AuthorizationSerializer(rank).data except Exception: if user.is_superuser: usertype = choices.ADMIN else: usertype = choices.LOGGED_USER serializer_rank = UserLevelPermission.objects.get( user_type_id=usertype) rank = UserLevelPermissionSerializer(serializer_rank).data data['rank'][project.slug] = rank project_authorized = Authorization.objects.filter(user=user).filter( level__rank__lte=2).values_list('project__pk', flat=True) serialized_projects = ProjectDetailedSerializer(Project.objects.filter( Q(pk__in=project_authorized) | Q(creator=user)).order_by('-created_on'), many=True) all_events = Event.objects.filter(user=user).order_by('-created_on') serialized_events = EventSerializer(all_events[0:5], many=True) feature_events = Event.objects.filter( user=user, object_type='feature').order_by('-created_on') serialized_feature_events = EventSerializer(feature_events[0:5], many=True) comment_events = Event.objects.filter( user=user, object_type='comment').order_by('-created_on') serialized_comment_events = EventSerializer(comment_events[0:5], many=True) data['projects'] = serialized_projects.data data['events'] = serialized_events.data data['features'] = serialized_feature_events.data data['comments'] = serialized_comment_events.data data['title'] = "Mon compte" return Response(data=data, status=status.HTTP_200_OK)
def get(self, request, slug): project = get_object_or_404(Project, slug=slug) form = ProjectModelForm(instance=project) context = { 'form': form, 'project': project, 'permissions': Authorization.all_permissions(request.user, project), 'feature_types': project.featuretype_set.all(), 'is_suscriber': Subscription.is_suscriber(request.user, project), 'action': 'update' } return render(request, 'geocontrib/project/project_edit.html', context)
def get(self, request): context = {} user = request.user # context['user'] = user # on liste les droits de l'utilisateur pour chaque projet context['permissions'] = {} context['rank'] = {} for project in Project.objects.all(): context['permissions'][ project.slug] = Authorization.has_permission( user, 'can_view_project', project) try: rank = Authorization.objects.get(project=project, user=user).level except Exception: if user.is_superuser: usertype = choices.ADMIN else: usertype = choices.LOGGED_USER rank = UserLevelPermission.objects.get(user_type_id=usertype) context['rank'][project.slug] = rank project_authorized = Authorization.objects.filter(user=user).filter( level__rank__lte=2).values_list('project__pk', flat=True) serilized_projects = ProjectDetailedSerializer(Project.objects.filter( Q(pk__in=project_authorized) | Q(creator=user)).order_by('-created_on'), many=True) all_events = Event.objects.filter(user=user).order_by('-created_on') serialized_events = EventSerializer(all_events[0:5], many=True) feature_events = Event.objects.filter( user=user, object_type='feature').order_by('-created_on') serialized_feature_events = EventSerializer(feature_events[0:5], many=True) comment_events = Event.objects.filter( user=user, object_type='comment').order_by('-created_on') serialized_comment_events = EventSerializer(comment_events[0:5], many=True) context['projects'] = serilized_projects.data context['events'] = serialized_events.data context['features'] = serialized_feature_events.data context['comments'] = serialized_comment_events.data return render(request, 'geocontrib/my_account.html', context)
def get(self, request, slug): project = self.get_object() user = request.user form = FeatureTypeModelForm() formset = self.CustomFieldsFormSet(queryset=CustomField.objects.none()) context = { 'form': form, 'formset': formset, 'permissions': Authorization.all_permissions(user, project), 'feature_types': project.featuretype_set.all(), 'project': project, } return render(request, 'geocontrib/feature_type/feature_type_create.html', context)
def get(self, request, slug): user = self.request.user project = self.get_object() permissions = Authorization.all_permissions(user, project) formset = ProjectBaseMapInlineFormset(instance=project) context = {**self.get_context_data(), **{ 'project': project, 'permissions': permissions, 'formset': formset, 'title': project.title, }} return render(request, 'geocontrib/project/project_mapping.html', context)
def post(self, request, slug): project = self.get_object() form = ProjectModelForm(request.POST, request.FILES, instance=project) if form.is_valid() and form.has_changed(): form.save() return redirect('geocontrib:project', slug=project.slug) context = { 'form': form, 'project': project, 'permissions': Authorization.all_permissions(request.user, project), 'feature_types': project.featuretype_set.all(), 'is_suscriber': Subscription.is_suscriber(request.user, project), 'action': 'update' } return render(request, 'geocontrib/project/project_edit.html', context)
def bulk_edit(self, project): validated_data = self.validated_data authorizations = [ Authorization(project=project, **item) for item in validated_data ] if not any( [row.level.user_type_id == 'admin' for row in authorizations]): raise serializers.ValidationError({ 'error': "Au moins un administrateur est requis par projet. " }) project.authorization_set.all().delete() try: instances = Authorization.objects.bulk_create(authorizations) except Exception as err: raise serializers.ValidationError( {'error': f"Échec de l'édition des permissions: {err}"}) return instances
def get(self, request, slug): user = self.request.user project = self.get_object() formset = self.AuthorizationFormSet( queryset=Authorization.objects.filter( project=project, user__is_active=True)) authorised = Authorization.objects.filter(project=project) permissions = Authorization.all_permissions(user, project) context = { "title": "Gestion des membres du projet {}".format(project.title), 'authorised': authorised, 'permissions': permissions, 'project': project, 'formset': formset, 'feature_types': FeatureType.objects.filter(project=project) } return render(request, 'geocontrib/project/project_members.html', context)
def get(self, request, slug, feature_type_slug): user = request.user feature_type = self.get_object() project = feature_type.project permissions = Authorization.all_permissions(user, project) extra = CustomField.objects.filter(feature_type=feature_type) feature_form = FeatureBaseForm(feature_type=feature_type, user=user) extra_form = FeatureExtraForm(extra=extra) linked_formset = self.LinkedFormset( form_kwargs={'feature_type': feature_type}, prefix='linked', queryset=FeatureLink.objects.none()) attachment_formset = self.AttachmentFormset( prefix='attachment', queryset=Attachment.objects.none()) context = { **self.get_context_data(), **{ 'features': Feature.handy.availables(user, project).order_by('updated_on'), 'feature_type': feature_type, 'project': project, 'permissions': permissions, 'feature_form': feature_form, 'extra_form': extra_form, 'linked_formset': linked_formset, 'attachment_formset': attachment_formset, 'action': 'create', } } return render(request, 'geocontrib/feature/feature_edit.html', context)
def custom_contexts(request): try: user_level_projects = Authorization.get_user_level_projects( request.user) except Exception: user_level_projects = {} logger.exception('Cannot retrieve user level project') return { 'APPLICATION_NAME': settings.APPLICATION_NAME, 'LOGO_PATH': settings.LOGO_PATH, 'APPLICATION_ABSTRACT': settings.APPLICATION_ABSTRACT, 'IMAGE_FORMAT': settings.IMAGE_FORMAT, 'FILE_MAX_SIZE': settings.FILE_MAX_SIZE, 'USER_LEVEL_PROJECTS': user_level_projects, 'SERVICE': settings.DEFAULT_BASE_MAP.get('SERVICE'), 'OPTIONS': json.dumps(settings.DEFAULT_BASE_MAP.get('OPTIONS')), 'DEFAULT_MAP_VIEW': settings.DEFAULT_MAP_VIEW }
def get(self, request, slug): user = self.request.user project = self.get_object() permissions = Authorization.all_permissions(user, project) # On filtre les signalements selon leur statut et l'utilisateur courant features = Feature.handy.availables( user=user, project=project).order_by('-created_on') # On filtre les commentaire selon les signalements visibles last_comments = Comment.objects.filter( project=project, feature_id__in=[feat.feature_id for feat in features]).order_by('-created_on')[0:5] serialized_comments = CommentSerializer(last_comments, many=True).data data = { 'last_comments': serialized_comments, } return Response(data, status=200)