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)
