class CollectionDeviceViewSet(mixins.UpdateModelMixin,
mixins.RetrieveModelMixin,
mixins.DestroyModelMixin,
utils.CustomViewSetMixin, GenericViewSet):
queryset = models.CollectionDevice.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.data_collections.devices)
permission_mapping = utils.PermissionMapping({
utils.Actions.UPDATE: [
IsAuthenticated,
(permissions.IsOwner | permissions.HasUpdatePermission | IsAdmin),
],
utils.Actions.RETRIEVE: [
IsAuthenticated,
(permissions.IsOwner | permissions.HasViewPermission
| permissions.IsCollectionAdmin
| permissions.IsCollectionTypeAdmin | IsSpecialUser),
],
utils.Actions.DESTROY: [
IsAuthenticated,
(permissions.IsOwner | IsAdmin),
]
})
class ItemTypeViewSet(mixins.RetrieveModelMixin, mixins.DestroyModelMixin,
mixins.UpdateModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.ItemType.objects.all() # pylint: disable=E1101
serializer_mapping = (utils.SerializerMapping.from_module(
serializers.object_types.items).extend(
add_event_types=serializers.object_types.events.SelectSerializer,
remove_event_types=serializers.object_types.events.SelectSerializer
))
permission_mapping = utils.PermissionMapping(
{
utils.Actions.RETRIEVE: IsAuthenticated,
utils.Actions.DESTROY: IsAdmin,
},
default=IsDeveloper | IsAdmin)
@action(detail=True, methods=['POST'])
def add_event_types(self, request, pk=None):
return self.add_related_object_view(models.EventType, 'event_type')
@action(detail=True, methods=['POST'])
def remove_event_types(self, request, pk=None):
return self.remove_related_object_view('event_type')
class AnnotationVoteViewSet(mixins.UpdateModelMixin,
mixins.RetrieveModelMixin,
mixins.DestroyModelMixin,
utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.AnnotationVote.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.annotations.votes)
permission_mapping = utils.PermissionMapping({
utils.Actions.UPDATE: [
IsAuthenticated,
permissions.IsCreator | IsAdmin,
],
utils.Actions.RETRIEVE: [
IsAuthenticated,
(
permissions.HasViewPermission |
permissions.IsCreator |
permissions.IsOpen |
IsSpecialUser
),
],
utils.Actions.DESTROY: [
IsAuthenticated,
permissions.IsCreator | IsAdmin,
],
})
class SiteViewSet(utils.CustomViewSetMixin, ModelViewSet):
queryset = models.Site.objects.all() # pylint: disable=E1101
filterset_class = filters.sites.Filter
search_fields = filters.sites.search_fields
serializer_mapping = (
utils.SerializerMapping
.from_module(serializers.sites)
.extend(
types=serializers.object_types.sites.ListSerializer,
add_type=serializers.object_types.sites.CreateSerializer,
))
permission_mapping = utils.PermissionMapping({
utils.Actions.UPDATE: [
IsAuthenticated,
(
permissions.IsCreator |
IsAdmin
)
],
utils.Actions.DESTROY: [
IsAuthenticated,
(
permissions.IsCreator |
IsAdmin
)
],
'add_type': [IsAuthenticated, IsAdmin]
}, default=IsAuthenticated)
def get_serializer_class(self):
if self.action == utils.Actions.RETRIEVE:
user = self.request.user
site = self.get_object()
if site.has_coordinate_permission(user):
return serializers.sites.FullDetailSerializer
return serializers.sites.DetailSerializer
return super().get_serializer_class()
def get_queryset(self):
if self.action == 'types':
return models.SiteType.objects.all() # pylint: disable=E1101
return super().get_queryset()
@action(
detail=False,
methods=['GET'],
filterset_class=filters.site_types.Filter,
search_fields=filters.site_types.search_fields)
def types(self, request):
return self.list_related_object_view()
@types.mapping.post
def add_type(self, request):
return self.create_related_object_view()
class SecondaryItemViewSet(mixins.UpdateModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.SecondaryItem.objects.all() # pylint: disable=E1101
permission_mapping = utils.PermissionMapping(
default=IsAuthenticated) # TODO: Fix permissions
serializer_mapping = utils.SerializerMapping.from_module(
serializers.items.secondary_items)
class AnnotationToolViewSet(mixins.UpdateModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.AnnotationTool.objects.all() # pylint: disable=E1101
permission_mapping = utils.PermissionMapping(default=IsAdmin | IsDeveloper
| ReadOnly)
serializer_mapping = utils.SerializerMapping.from_module(
serializers.annotations.tools)
class LicenceTypeViewSet(mixins.RetrieveModelMixin, mixins.DestroyModelMixin,
mixins.UpdateModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.LicenceType.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.object_types.licences)
permission_mapping = utils.PermissionMapping()
class CollectionTypeSiteTypeViewSet(mixins.RetrieveModelMixin,
mixins.DestroyModelMixin,
utils.CustomViewSetMixin, GenericViewSet):
queryset = models.CollectionType.site_types.through.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.object_types.data_collections.sites)
permission_mapping = utils.PermissionMapping()
class MetaCollectionViewSet(mixins.UpdateModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.MetaCollection.objects.all() # pylint: disable=E1101
filterset_class = filters.metacollections.Filter
search_fields = filters.metacollections.search_fields
serializer_mapping = (utils.SerializerMapping.from_module(
serializers.data_collections.metacollections).extend(
items=serializers.items.items.ListSerializer,
add_item=serializers.items.items.SelectSerializer,
remove_item=serializers.items.items.SelectSerializer,
add_curator=serializers.users.users.SelectSerializer,
remove_curator=serializers.users.users.SelectSerializer,
))
permission_mapping = utils.PermissionMapping(
{
utils.Actions.LIST: [IsAuthenticated],
utils.Actions.RETRIEVE: [IsAuthenticated, IsSpecialUser],
'items': [IsAuthenticated, IsSpecialUser],
'add_curator': [IsAuthenticated, IsAdmin],
'remove_curator': [IsAuthenticated, IsAdmin],
},
default=[IsAuthenticated, IsDeveloper | IsAdmin])
def get_queryset(self):
if self.action == 'items':
metacollection_id = self.kwargs['pk']
metacollection = models.MetaCollection.objects.get(
pk=metacollection_id) # pylint: disable=E1101
return metacollection.items.all()
return super().get_queryset()
@action(detail=True, methods=['POST'])
def add_item(self, request, pk=None):
return self.add_related_object_view(models.Item, 'item')
@action(detail=True, methods=['POST'])
def remove_item(self, request, pk=None):
return self.remove_related_object_view('item')
@action(detail=True, methods=['POST'])
def add_curator(self, request, pk=None):
return self.add_related_object_view(models.User, 'curator')
@action(detail=True, methods=['POST'])
def remove_curator(self, request, pk=None):
return self.remove_related_object_view('curator')
@action(detail=True,
methods=['GET'],
filterset_class=filters.items.Filter,
search_fields=filters.items.search_fields)
def items(self, request, pk=None):
return self.list_related_object_view()
class EntailmentTypeViewSet(mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, mixins.UpdateModelMixin,
utils.CustomViewSetMixin, GenericViewSet):
queryset = models.EntailmentType.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.object_types.entailments)
permission_mapping = utils.PermissionMapping(default=IsDeveloper | IsAdmin
| ReadOnly)
class CollectionAdministratorViewSet(mixins.RetrieveModelMixin,
mixins.DestroyModelMixin,
utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.Collection.administrators.through.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.data_collections.administrators)
permission_mapping = utils.PermissionMapping() # TODO: Fix permissions
class TermSuggestionViewSet(mixins.UpdateModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.TermSuggestion.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.terms.suggestions)
permission_mapping = utils.PermissionMapping(
default=permissions.IsOwnSuggestion | IsAdmin | ReadOnly)
class PhysicalDeviceViewSet(mixins.UpdateModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.PhysicalDevice.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.devices.physical_devices)
permission_mapping = utils.PermissionMapping(default=permissions.IsOwner
| IsAdmin | ReadOnly)
class SynonymViewSet(mixins.UpdateModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.Synonym.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.terms.synonyms)
permission_mapping = utils.PermissionMapping(default=IsAdmin | IsCurator
| ReadOnly)
class DeviceBrandViewSet(mixins.RetrieveModelMixin,
mixins.DestroyModelMixin,
mixins.UpdateModelMixin,
utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.DeviceBrand.objects.all() # pylint: disable=E1101
permission_mapping = utils.PermissionMapping(default=IsAdmin | ReadOnly)
serializer_mapping = utils.SerializerMapping.from_module(
serializers.devices.brands)
class MimeTypeViewSet(mixins.RetrieveModelMixin, mixins.DestroyModelMixin,
mixins.UpdateModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.MimeType.objects.all() # pylint: disable=E1101
serializer_mapping = (utils.SerializerMapping.from_module(
serializers.object_types.mime_types))
permission_mapping = utils.PermissionMapping(
{
utils.Actions.RETRIEVE: IsAuthenticated,
utils.Actions.DESTROY: IsAdmin,
},
default=IsDeveloper | IsAdmin)
class InstitutionViewSet(mixins.UpdateModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.Institution.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.users.institutions)
permission_mapping = utils.PermissionMapping(
{
utils.Actions.UPDATE:
[IsAuthenticated, (permissions.IsFromInstitution | IsAdmin)],
utils.Actions.DESTROY: [IsAuthenticated, IsAdmin],
},
default=IsAuthenticated)
class LicenceViewSet(mixins.UpdateModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.Licence.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.licences)
permission_mapping = utils.PermissionMapping({
utils.Actions.UPDATE:
[IsAuthenticated, (permissions.IsSigner | IsAdmin)],
utils.Actions.RETRIEVE:
IsAuthenticated,
utils.Actions.DESTROY:
[IsAuthenticated, (permissions.IsSigner | IsAdmin)],
})
class SynonymSuggestionViewSet(mixins.UpdateModelMixin,
mixins.RetrieveModelMixin,
mixins.DestroyModelMixin,
utils.CustomViewSetMixin, GenericViewSet):
queryset = models.SynonymSuggestion.objects.all() # pylint: disable=E1101
serializer_mapping = utils.SerializerMapping.from_module(
serializers.terms.synonym_suggestions)
permission_mapping = utils.PermissionMapping(
{
utils.Actions.UPDATE: [
IsAuthenticated, # TODO: Fix permissions
],
utils.Actions.DESTROY: [IsAuthenticated, IsAdmin]
},
default=IsAuthenticated)
class RoleViewSet(mixins.UpdateModelMixin, mixins.DestroyModelMixin,
mixins.RetrieveModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.Role.objects.all() # pylint: disable=E1101
serializer_mapping = (utils.SerializerMapping.from_module(
serializers.users.roles).extend(
add_permission=serializers.users.roles.SelectPermissionSerializer,
remove_permission=serializers.users.roles.
SelectPermissionSerializer))
permission_mapping = utils.PermissionMapping(default=IsAdmin | ReadOnly)
@action(detail=True, methods=['POST'])
def add_permission(self, request, pk=None):
return self.add_related_object_view(Permission, 'permission')
@action(detail=True, methods=['POST'])
def remove_permission(self, request, pk=None):
return self.remove_related_object_view('permission')
class AnnotationTypeViewSet(mixins.RetrieveModelMixin,
mixins.DestroyModelMixin,
mixins.UpdateModelMixin,
utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.AnnotationType.objects.all() # pylint: disable=E1101
permission_mapping = utils.PermissionMapping({
utils.Actions.UPDATE: [
IsAuthenticated,
IsDeveloper | IsAdmin,
],
utils.Actions.DESTROY: [
IsAuthenticated,
IsAdmin,
],
})
serializer_mapping = utils.SerializerMapping.from_module(
serializers.object_types.annotations)
class CollectionUserViewSet(mixins.UpdateModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.CollectionUser.objects.all() # pylint: disable=E1101
serializer_mapping = (utils.SerializerMapping.from_module(
serializers.data_collections.users).extend(
change_role=serializers.data_collections.users.RoleSerializer))
permission_mapping = utils.PermissionMapping({
utils.Actions.UPDATE: [
IsAuthenticated,
(permissions.IsSelf | permissions.HasUpdatePermission
| permissions.IsCollectionAdmin
| permissions.IsCollectionTypeAdmin | IsAdmin),
],
utils.Actions.RETRIEVE: [
IsAuthenticated,
(permissions.IsSelf | permissions.IsInCollection
| permissions.IsCollectionAdmin
| permissions.IsCollectionTypeAdmin | IsSpecialUser),
],
utils.Actions.DESTROY: [
IsAuthenticated,
(permissions.IsSelf | IsAdmin),
],
'change_role': [(permissions.IsCollectionAdmin
| permissions.IsCollectionTypeAdmin | IsAdmin)],
})
@action(detail=True, methods=['POST'])
def change_role(self, request, pk=None):
instance = self.get_object()
serializer = self.get_serializer(instance,
data=request.data,
partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
class CollectionTypeViewSet(mixins.RetrieveModelMixin,
mixins.DestroyModelMixin,
mixins.UpdateModelMixin,
utils.CustomViewSetMixin,
GenericViewSet):
queryset = models.CollectionType.objects.all() # pylint: disable=E1101
permission_mapping = utils.PermissionMapping()
serializer_mapping = (
utils.SerializerMapping
.from_module(serializers.object_types.data_collections.types)
.extend(
administrators=serializers.object_types.data_collections.administrators.ListSerializer, # noqa pylint: disable=C0301
add_administrator=serializers.object_types.data_collections.administrators.CreateSerializer, # noqa pylint: disable=C0301
site_types=serializers.object_types.data_collections.sites.ListSerializer, # noqa pylint: disable=C0301
add_site_type=serializers.object_types.data_collections.sites.CreateSerializer, # noqa pylint: disable=C0301
annotation_types=serializers.object_types.data_collections.annotations.ListSerializer, # noqa pylint: disable=C0301
add_annotation_type=serializers.object_types.data_collections.annotations.CreateSerializer, # noqa pylint: disable=C0301
licence_types=serializers.object_types.data_collections.licences.ListSerializer, # noqa pylint: disable=C0301
add_licence_type=serializers.object_types.data_collections.licences.CreateSerializer, # noqa pylint: disable=C0301
sampling_event_types=serializers.object_types.data_collections.sampling_events.ListSerializer, # noqa pylint: disable=C0301
add_sampling_event_type=serializers.object_types.data_collections.sampling_events.CreateSerializer, # noqa pylint: disable=C0301
item_types=serializers.object_types.data_collections.items.ListSerializer, # noqa pylint: disable=C0301
add_item_type=serializers.object_types.data_collections.items.CreateSerializer, # noqa pylint: disable=C0301
event_types=serializers.object_types.data_collections.events.ListSerializer, # noqa pylint: disable=C0301
add_event_type=serializers.object_types.data_collections.events.CreateSerializer, # noqa pylint: disable=C0301
device_types=serializers.object_types.data_collections.devices.ListSerializer, # noqa pylint: disable=C0301
add_device_type=serializers.object_types.data_collections.devices.CreateSerializer, # noqa pylint: disable=C0301
roles=serializers.object_types.data_collections.roles.ListSerializer, # noqa pylint: disable=C0301
add_role=serializers.object_types.data_collections.roles.CreateSerializer, # noqa pylint: disable=C0301
))
def get_object(self):
type_pk = self.kwargs['pk']
type = get_object_or_404(models.CollectionType, pk=type_pk)
self.check_object_permissions(self.request, type)
return type
def get_serializer_context(self):
context = super().get_serializer_context()
try:
collection_type = self.get_object()
except (KeyError, AttributeError, AssertionError):
collection_type = None
context['collection_type'] = collection_type
return context
def get_queryset(self):
if self.action == 'site_types':
model = models.CollectionType.site_types.through # pylint: disable=E1101
collection_id = self.kwargs['pk']
return model.objects.filter(collectiontype_id=collection_id)
if self.action == 'administrators':
model = models.CollectionType.administrators.through # pylint: disable=E1101
collection_id = self.kwargs['pk']
return model.objects.filter(collectiontype_id=collection_id)
if self.action == 'annotation_types':
model = models.CollectionType.annotation_types.through # pylint: disable=E1101
collection_id = self.kwargs['pk']
return model.objects.filter(collectiontype_id=collection_id)
if self.action == 'licence_types':
model = models.CollectionType.licence_types.through # pylint: disable=E1101
collection_id = self.kwargs['pk']
return model.objects.filter(collectiontype_id=collection_id)
if self.action == 'sampling_event_types':
model = models.CollectionType.sampling_event_types.through # pylint: disable=E1101
collection_id = self.kwargs['pk']
return model.objects.filter(collectiontype_id=collection_id)
if self.action == 'item_types':
collection_id = self.kwargs['pk']
return models.CollectionItemType.objects.filter( # pylint: disable=E1101
collection_type=collection_id)
if self.action == 'event_types':
model = models.CollectionType.event_types.through # pylint: disable=E1101
collection_id = self.kwargs['pk']
return model.objects.filter(collectiontype_id=collection_id)
if self.action == 'device_types':
collection_id = self.kwargs['pk']
return models.CollectionDeviceType.objects.filter( # pylint: disable=E1101
collection_type=collection_id)
if self.action == 'roles':
collection_id = self.kwargs['pk']
return models.CollectionRole.objects.filter( # pylint: disable=E1101
collection_type=collection_id)
return super().get_queryset()
@action(detail=True, methods=['GET'])
def site_types(self, request, pk=None):
return self.list_related_object_view()
@site_types.mapping.post
def add_site_type(self, request, pk=None):
return self.create_related_object_view()
@action(detail=True, methods=['GET'])
def administrators(self, request, pk=None):
return self.list_related_object_view()
@administrators.mapping.post
def add_administrator(self, request, pk=None):
return self.create_related_object_view()
@action(detail=True, methods=['GET'])
def annotation_types(self, request, pk=None):
return self.list_related_object_view()
@annotation_types.mapping.post
def add_annotation_type(self, request, pk=None):
return self.create_related_object_view()
@action(detail=True, methods=['GET'])
def licence_types(self, request, pk=None):
return self.list_related_object_view()
@licence_types.mapping.post
def add_licence_type(self, request, pk=None):
return self.create_related_object_view()
@action(detail=True, methods=['GET'])
def sampling_event_types(self, request, pk=None):
return self.list_related_object_view()
@sampling_event_types.mapping.post
def add_sampling_event_type(self, request, pk=None):
return self.create_related_object_view()
@action(detail=True, methods=['GET'])
def item_types(self, request, pk=None):
return self.list_related_object_view()
@item_types.mapping.post
def add_item_type(self, request, pk=None):
return self.create_related_object_view()
@action(detail=True, methods=['GET'])
def event_types(self, request, pk=None):
return self.list_related_object_view()
@event_types.mapping.post
def add_event_type(self, request, pk=None):
return self.create_related_object_view()
@action(detail=True, methods=['GET'])
def device_types(self, request, pk=None):
return self.list_related_object_view()
@device_types.mapping.post
def add_device_type(self, request, pk=None):
return self.create_related_object_view()
@action(detail=True, methods=['GET'])
def roles(self, request, pk=None):
return self.list_related_object_view()
@roles.mapping.post
def add_role(self, request, pk=None):
return self.create_related_object_view()
class SamplingEventViewSet(mixins.UpdateModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, mixins.ListModelMixin,
utils.CustomViewSetMixin, GenericViewSet):
queryset = models.SamplingEvent.objects.all() # pylint: disable=E1101
search_fields = filters.sampling_events.search_fields
filterset_class = filters.sampling_events.Filter
serializer_mapping = (utils.SerializerMapping.from_module(
serializers.sampling_events.sampling_events).extend(
items=serializers.items.items.ListSerializer,
devices=serializers.sampling_events.devices.ListSerializer,
add_device=serializers.sampling_events.devices.CreateSerializer,
))
permission_mapping = utils.PermissionMapping({
utils.Actions.UPDATE: [
IsAuthenticated,
(permissions.IsCreator | permissions.HasChangePermissions
| IsAdmin)
],
utils.Actions.RETRIEVE: [
IsAuthenticated,
(permissions.IsCreator | permissions.HasViewPermissions
| permissions.IsCollectionAdmin
| permissions.IsCollectionTypeAdmin | IsSpecialUser)
],
utils.Actions.DESTROY:
[IsAuthenticated, (permissions.IsCreator | IsAdmin)],
utils.Actions.LIST: [
IsAuthenticated,
],
'items': [
IsAuthenticated,
(permissions.IsCreator | permissions.HasViewItemsPermissions
| permissions.IsCollectionAdmin
| permissions.IsCollectionTypeAdmin | IsAdmin)
],
})
def get_object(self):
sampling_event_pk = self.kwargs['pk']
sampling_event = get_object_or_404(models.SamplingEvent,
pk=sampling_event_pk)
self.check_object_permissions(self.request, sampling_event)
return sampling_event
def get_serializer_context(self):
context = super().get_serializer_context()
try:
sampling_event = self.get_object()
except (KeyError, AssertionError, AttributeError):
sampling_event = None
context['sampling_event'] = sampling_event
return context
def get_queryset(self):
if self.action == 'devices':
object_id = self.kwargs['pk']
return models.SamplingEventDevice.objects.filter(
sampling_event=object_id) # pylint: disable=E1101
if self.action == 'items' or self.action == 'item_locations':
object_id = self.kwargs['pk']
return models.Item.objects.filter( # pylint: disable=E1101
sampling_event_device__sampling_event=object_id)
return super().get_queryset()
@action(detail=True,
methods=['GET'],
filterset_class=filters.sampling_event_devices.Filter,
search_fields=filters.sampling_event_devices.search_fields)
def devices(self, request, pk=None):
return self.list_related_object_view()
@devices.mapping.post
def add_device(self, request, pk=None):
return self.create_related_object_view()
@action(detail=True,
methods=['GET'],
filterset_class=filters.items.Filter,
search_fields=filters.items.search_fields)
def items(self, request, pk=None):
return self.list_related_object_view()
@action(detail=True, methods=['GET'])
def location(self, request, pk=None):
sampling_event = self.get_object()
serializer = serializers.sites.SamplingEventLocationSerializer(
[sampling_event], many=True)
return Response(serializer.data)
@action(detail=True,
methods=['GET'],
filterset_class=filters.items.Filter,
search_fields=filters.items.search_fields)
def item_locations(self, request, pk=None):
queryset = self.filter_queryset(self.get_queryset())
serializer = serializers.sites.ItemLocationSerializer(queryset,
many=True,
read_only=True)
return Response(serializer.data)
class TermTypeViewSet(utils.CustomViewSetMixin, ModelViewSet):
queryset = models.TermType.objects.all() # pylint: disable=E1101
search_fields = filters.term_types.search_fields
filterset_class = filters.term_types.Filter
serializer_mapping = (utils.SerializerMapping.from_module(
serializers.object_types.terms
).extend(
terms=serializers.terms.terms.ListSerializer,
add_term=serializers.terms.terms.CreateSerializer,
suggestions=serializers.terms.suggestions.ListSerializer,
suggest_term=serializers.terms.suggestions.CreateSerializer,
entailment_types=serializers.object_types.entailments.ListSerializer,
add_entailment_type=serializers.object_types.entailments.
CreateSerializer,
entailments=serializers.terms.entailments.ListSerializer,
add_entailment=serializers.terms.entailments.CreateSerializer,
synonyms=serializers.terms.synonyms.ListSerializer,
add_synonym=serializers.terms.synonyms.CreateSerializer,
synonym_suggestions=serializers.terms.synonym_suggestions.
ListSerializer,
suggest_synonym=serializers.terms.synonym_suggestions.CreateSerializer,
))
permission_mapping = utils.PermissionMapping(
{
utils.Actions.DESTROY: [IsAuthenticated, IsAdmin],
utils.Actions.CREATE: [IsAuthenticated, IsAdmin],
utils.Actions.UPDATE: [IsAuthenticated, IsAdmin],
'add_term': [IsAuthenticated, IsAdmin],
'add_entailment_type': [IsAuthenticated, IsAdmin],
'add_entailment': [IsAuthenticated, IsAdmin],
'add_synonym': [IsAuthenticated, IsAdmin],
},
default=IsAuthenticated)
def get_object(self):
type_pk = self.kwargs['pk']
term_type = get_object_or_404(models.TermType, pk=type_pk)
self.check_object_permissions(self.request, term_type)
return term_type
def get_serializer_context(self):
context = super().get_serializer_context()
try:
term_type = self.get_object()
except (KeyError, AssertionError, AttributeError):
term_type = None
context['term_type'] = term_type
return context
def get_queryset(self):
if self.action == 'entailments':
return models.Entailment.objects.all() # pylint: disable=E1101
if self.action == 'entailment_types':
return models.EntailmentType.objects.all() # pylint: disable=E1101
if self.action == 'terms':
term_type_id = self.kwargs['pk']
return models.Term.objects.filter(term_type=term_type_id) # pylint: disable=E1101
if self.action == 'synonyms':
term_type_id = self.kwargs['pk']
return models.Synonym.objects.filter(
source__term_type=term_type_id) # pylint: disable=E1101
if self.action == 'suggestions':
term_type_id = self.kwargs['pk']
return models.TermSuggestion.objects.filter(term_type=term_type_id) # pylint: disable=E1101
if self.action == 'synonym_suggestions':
term_type_id = self.kwargs['pk']
return models.SynonymSuggestion.objects.filter(
source__term_type=term_type_id) # pylint: disable=E1101
return super().get_queryset()
@action(detail=False,
methods=['GET'],
filterset_class=filters.entailments.Filter,
search_fields=filters.entailments.search_fields)
def entailments(self, request):
return self.list_related_object_view()
@entailments.mapping.post
def add_entailment(self, request):
self.create_related_object_view()
@action(detail=False,
methods=['GET'],
filterset_class=filters.entailment_types.Filter,
search_fields=filters.entailment_types.search_fields)
def entailment_types(self, request):
return self.list_related_object_view()
@entailment_types.mapping.post
def add_entailment_type(self, request):
self.create_related_object_view()
@action(detail=True,
methods=['GET'],
filterset_class=filters.terms.Filter,
search_fields=filters.terms.search_fields)
def terms(self, request, pk=None):
return self.list_related_object_view()
@terms.mapping.post
def add_term(self, request, pk=None):
return self.create_related_object_view()
@action(detail=True,
methods=['GET'],
filterset_class=filters.synonyms.Filter,
search_fields=filters.synonyms.search_fields)
def synonyms(self, request, pk=None):
return self.list_related_object_view()
@synonyms.mapping.post
def add_synonym(self, request, pk=None):
self.create_related_object_view()
@action(detail=True,
methods=['GET'],
filterset_class=filters.term_suggestions.Filter,
search_fields=filters.term_suggestions.search_fields)
def suggestions(self, request, pk=None):
return self.list_related_object_view()
@suggestions.mapping.post
def suggest_term(self, request, pk=None):
self.create_related_object_view()
@action(detail=True,
methods=['GET'],
filterset_class=filters.synonym_suggestions.Filter,
search_fields=filters.synonym_suggestions.search_fields)
def synonym_suggestions(self, request, pk=None):
return self.list_related_object_view()
@synonym_suggestions.mapping.post
def suggest_synonym(self, request, pk=None):
self.create_related_object_view()
class CollectionViewSet(utils.CustomViewSetMixin, ModelViewSet):
queryset = models.Collection.objects.all() # pylint: disable=E1101
search_fields = filters.data_collections.search_fields
filterset_class = filters.data_collections.Filter
serializer_mapping = (
utils.SerializerMapping
.from_module(serializers.data_collections.data_collections)
.extend(
metacollections=serializers.data_collections.metacollections.ListSerializer,
add_metacollection=serializers.data_collections.metacollections.CreateSerializer,
licences=serializers.licences.ListSerializer,
add_licence=serializers.licences.CreateSerializer,
devices=serializers.data_collections.devices.ListSerializer,
add_device=serializers.data_collections.devices.CreateSerializer,
sites=serializers.data_collections.sites.ListSerializer,
add_site=serializers.data_collections.sites.CreateSerializer,
users=serializers.data_collections.users.ListSerializer,
add_user=serializers.data_collections.users.CreateSerializer,
sampling_events=serializers.sampling_events.sampling_events.ListSerializer,
add_sampling_event=serializers.sampling_events.sampling_events.CreateSerializer,
types=serializers.object_types.data_collections.types.ListSerializer,
add_type=serializers.object_types.data_collections.types.CreateSerializer,
licence_types=serializers.object_types.licences.ListSerializer,
add_licence_type=serializers.object_types.licences.CreateSerializer,
items=serializers.items.items.ListSerializer,
administrators=serializers.data_collections.administrators.ListSerializer,
add_administrator=serializers.data_collections.administrators.CreateSerializer,
))
permission_mapping = utils.PermissionMapping({
utils.Actions.UPDATE: [
IsAuthenticated,
(
permissions.HasUpdatePermission |
permissions.IsCollectionAdmin |
permissions.IsCollectionTypeAdmin |
IsAdmin
)
],
utils.Actions.DESTROY: [
IsAuthenticated,
permissions.IsCollectionAdmin | IsAdmin
],
'add_licence_type': [
IsAuthenticated, IsAdmin
],
'add_metacollection': [
IsAuthenticated, IsAdmin | IsDeveloper
],
'licences': [
IsAuthenticated,
(
permissions.IsCollectionUser |
IsSpecialUser
),
],
'add_licence': [
IsAuthenticated,
(
permissions.HasAddLicencePermission |
permissions.IsCollectionAdmin
),
],
'devices': [
IsAuthenticated,
(
permissions.IsCollectionUser |
permissions.IsCollectionTypeAdmin |
IsSpecialUser
)
],
'add_device': [
IsAuthenticated,
(
permissions.HasAddDevicePermission |
permissions.IsCollectionAdmin |
IsAdmin
)
],
'sites': [
IsAuthenticated,
(
permissions.IsCollectionUser |
permissions.IsCollectionTypeAdmin |
IsSpecialUser
)
],
'add_site': [
IsAuthenticated,
(
permissions.HasAddSitePermission |
permissions.IsCollectionAdmin |
permissions.IsCollectionTypeAdmin |
IsAdmin
)
],
'users': [
IsAuthenticated,
(
permissions.IsCollectionUser |
permissions.IsCollectionTypeAdmin |
IsSpecialUser
)
],
'add_user': [
IsAuthenticated,
(
permissions.HasAddUserPermission |
permissions.IsCollectionAdmin |
permissions.IsCollectionTypeAdmin |
IsAdmin
)
],
'sampling_events': [
IsAuthenticated,
(
permissions.IsCollectionUser |
permissions.IsCollectionTypeAdmin |
IsSpecialUser
)
],
'add_sampling_event': [
IsAuthenticated,
(
permissions.HasAddItemPermission |
permissions.IsCollectionAdmin |
permissions.IsCollectionTypeAdmin |
IsAdmin
)
],
'items': [
IsAuthenticated,
(
permissions.IsCollectionUser |
permissions.IsCollectionTypeAdmin |
IsSpecialUser
)
],
'add_type': [IsAuthenticated, IsAdmin],
'add_administrator': [
IsAuthenticated,
(
permissions.IsCollectionAdmin |
permissions.IsCollectionTypeAdmin |
IsAdmin
)
],
})
def get_object(self):
collection_id = self.kwargs['pk']
collection = get_object_or_404(models.Collection, pk=collection_id)
self.check_object_permissions(self.request, collection)
return collection
def get_serializer_context(self):
context = super().get_serializer_context()
try:
collection = self.get_object()
except (KeyError, AssertionError, AttributeError):
collection = None
context['collection'] = collection
return context
def get_queryset(self):
if self.action == 'metacollections':
return models.MetaCollection.objects.all() # pylint: disable=E1101
if self.action == 'licences':
collection_id = self.kwargs['pk']
return models.Licence.objects.filter(collection=collection_id) # pylint: disable=E1101
if self.action == 'devices':
collection_id = self.kwargs['pk']
return models.CollectionDevice.objects.filter(collection=collection_id) # pylint: disable=E1101
if self.action == 'sites':
collection_id = self.kwargs['pk']
return models.CollectionSite.objects.filter(collection=collection_id) # pylint: disable=E1101
if self.action == 'users':
collection_id = self.kwargs['pk']
return models.CollectionUser.objects.filter(collection=collection_id) # pylint: disable=E1101
if self.action == 'sampling_events':
collection_id = self.kwargs['pk']
return models.SamplingEvent.objects.filter(collection=collection_id) # pylint: disable=E1101
if self.action == 'types':
return models.CollectionType.objects.all() # pylint: disable=E1101
if self.action == 'licence_types':
return models.LicenceType.objects.all() # pylint: disable=E1101
if self.action == 'items':
collection_id = self.kwargs['pk']
return models.Item.objects.filter( # pylint: disable=E1101
sampling_event_device__sampling_event__collection=collection_id)
if self.action == 'administrators':
model = models.Collection.administrators.through
collection_id = self.kwargs['pk']
return model.objects.filter(collection=collection_id)
if self.action == 'item_locations':
collection_id = self.kwargs['pk']
return self.get_item_locations_queryset(collection_id)
if self.action == 'site_locations':
collection_id = self.kwargs['pk']
return self.get_site_locations_queryset(collection_id)
if self.action == 'sampling_event_locations':
collection_id = self.kwargs['pk']
return self.get_sampling_event_locations_queryset(collection_id)
return super().get_queryset()
def get_item_locations_queryset(self, collection_id):
# TODO: Fix queryset filtering for user
return models.Item.objects.filter( # pylint: disable=E1101
sampling_event_device__sampling_event__collection=collection_id)
def get_site_locations_queryset(self, collection_id):
# TODO: Fix queryset filtering for user
return models.CollectionSite.objects.filter(collection=collection_id) # pylint: disable=E1101
def get_sampling_event_locations_queryset(self, collection_id):
# TODO: Fix queryset filtering for user
return models.SamplingEvent.objects.filter(collection=collection_id) # pylint: disable=E1101
@action(
detail=False,
methods=['GET'],
filterset_class=filters.metacollections.Filter,
search_fields=filters.metacollections.search_fields)
def metacollections(self, request):
return self.list_related_object_view()
@metacollections.mapping.post
def add_metacollection(self, request):
return self.create_related_object_view()
@action(
detail=True,
methods=['GET'],
filterset_class=filters.licences.Filter,
search_fields=filters.licences.search_fields)
def licences(self, request, pk=None):
return self.list_related_object_view()
@licences.mapping.post
def add_licence(self, request, pk=None):
return self.create_related_object_view()
@action(
detail=True,
methods=['GET'],
filterset_class=filters.collection_devices.Filter,
search_fields=filters.collection_devices.search_fields)
def devices(self, request, pk=None):
return self.list_related_object_view()
@devices.mapping.post
def add_device(self, request, pk=None):
return self.create_related_object_view()
@action(
detail=True,
methods=['GET'],
filterset_class=filters.collection_sites.Filter,
search_fields=filters.collection_sites.search_fields)
def sites(self, request, pk=None):
return self.list_related_object_view()
@sites.mapping.post
def add_site(self, request, pk=None):
return self.create_related_object_view()
@action(
detail=True,
methods=['GET'],
filterset_class=filters.collection_users.Filter,
search_fields=filters.collection_users.search_fields)
def users(self, request, pk=None):
return self.list_related_object_view()
@users.mapping.post
def add_user(self, request, pk=None):
return self.create_related_object_view()
@action(
detail=True,
methods=['GET'],
filterset_class=filters.sampling_events.Filter,
search_fields=filters.sampling_events.search_fields)
def sampling_events(self, request, pk=None):
return self.list_related_object_view()
@sampling_events.mapping.post
def add_sampling_event(self, request, pk=None):
return self.create_related_object_view()
@action(
detail=False,
methods=['GET'],
filterset_class=filters.collection_types.Filter,
search_fields=filters.collection_types.search_fields)
def types(self, request):
return self.list_related_object_view()
@types.mapping.post
def add_type(self, request):
return self.create_related_object_view()
@action(
detail=False,
methods=['GET'],
filterset_class=filters.licence_types.Filter,
search_fields=filters.licence_types.search_fields)
def licence_types(self, request):
return self.list_related_object_view()
@licence_types.mapping.post
def add_licence_type(self, request):
return self.create_related_object_view()
@action(
detail=True,
methods=['GET'],
filterset_class=filters.collection_administrators.Filter,
search_fields=filters.collection_administrators.search_fields)
def administrators(self, request, pk=None):
return self.list_related_object_view()
@administrators.mapping.post
def add_administrator(self, request, pk=None):
return self.create_related_object_view()
@action(
detail=True,
methods=['GET'],
filterset_class=filters.items.Filter,
search_fields=filters.items.search_fields)
def items(self, request, pk=None):
return self.list_related_object_view()
@action(
detail=True,
methods=['GET'],
filterset_class=filters.collection_sites.Filter,
search_fields=filters.collection_sites.search_fields)
def site_locations(self, request, pk=None):
queryset = self.filter_queryset(self.get_queryset())
serializer = serializers.sites.CollectionSiteLocationSerializer(
queryset,
many=True,
read_only=True)
return Response(serializer.data)
@action(
detail=True,
methods=['GET'],
filterset_class=filters.items.Filter,
search_fields=filters.items.search_fields)
def item_locations(self, request, pk=None):
queryset = self.filter_queryset(self.get_queryset())
serializer = serializers.sites.ItemLocationSerializer(
queryset,
many=True,
read_only=True)
return Response(serializer.data)
@action(
detail=True,
methods=['GET'],
filterset_class=filters.sampling_events.Filter,
search_fields=filters.sampling_events.search_fields)
def sampling_event_locations(self, request, pk=None):
queryset = self.filter_queryset(self.get_queryset())
serializer = serializers.sites.SamplingEventLocationSerializer(
queryset,
many=True,
read_only=True)
return Response(serializer.data)
class SamplingEventTypeViewSet(mixins.RetrieveModelMixin,
mixins.DestroyModelMixin,
utils.CustomViewSetMixin, GenericViewSet):
queryset = models.SamplingEventType.objects.all() # pylint: disable=E1101
serializer_mapping = (utils.SerializerMapping.from_module(
serializers.object_types.sampling_events.types).extend(
device_types=serializers.object_types.sampling_events.devices.
ListSerializer,
add_device_types=serializers.object_types.sampling_events.devices.
CreateSerializer,
site_types=serializers.object_types.sampling_events.sites.
ListSerializer,
add_site_types=serializers.object_types.sampling_events.sites.
CreateSerializer,
))
permission_mapping = utils.PermissionMapping()
def get_object(self):
sampling_event_pk = self.kwargs['pk']
sampling_event = get_object_or_404(models.SamplingEventType,
pk=sampling_event_pk)
self.check_object_permissions(self.request, sampling_event)
return sampling_event
def get_serializer_context(self):
context = super().get_serializer_context()
try:
sampling_event_type = self.get_object()
except (KeyError, AttributeError, AssertionError):
sampling_event_type = None
context['sampling_event_type'] = sampling_event_type
return context
def get_queryset(self):
if self.action == 'device_types':
sampling_event_type_id = self.kwargs['pk']
queryset = (
models.SamplingEventTypeDeviceTypeViewSet # pylint: disable=E1101
.objects.filter(sampling_event_type=sampling_event_type_id))
return queryset
if self.action == 'site_types':
model = models.SamplingEventType.site_types.through # pylint: disable=E1101
sampling_event_type_id = self.kwargs['pk']
return model.objects.filter(
samplingeventtype_id=sampling_event_type_id)
return super().get_queryset()
@action(detail=True, methods=['GET'])
def device_types(self, request, pk=None):
return self.list_related_object_view()
@device_types.mapping.post
def add_device_types(self, request, pk=None):
return self.create_related_object_view()
@action(detail=True, methods=['GET'])
def site_types(self, request, pk=None):
return self.list_related_object_view()
@site_types.mapping.post
def add_site_types(self, request, pk=None):
return self.create_related_object_view()
class AnnotationViewSet(mixins.UpdateModelMixin, mixins.RetrieveModelMixin,
mixins.DestroyModelMixin, mixins.ListModelMixin,
utils.CustomViewSetMixin, GenericViewSet):
queryset = models.Annotation.objects.all() # pylint: disable=E1101
filterset_class = filters.annotations.Filter
search_fields = filters.annotations.search_fields
serializer_mapping = (utils.SerializerMapping.from_module(
serializers.annotations.annotations).extend(
vote=serializers.annotations.votes.CreateSerializer,
votes=serializers.annotations.votes.ListSerializer,
types=serializers.object_types.annotations.ListSerializer,
add_type=serializers.object_types.annotations.CreateSerializer,
tools=serializers.annotations.tools.ListSerializer,
add_tool=serializers.annotations.tools.CreateSerializer,
))
permission_mapping = utils.PermissionMapping(
{
utils.Actions.UPDATE: [
IsAuthenticated,
(permissions.IsCreator | permissions.HasUpdatePermission
| IsCurator | IsAdmin),
],
utils.Actions.RETRIEVE: [
IsAuthenticated,
(permissions.IsCreator | permissions.HasViewPermission
| permissions.IsCollectionAdmin
| permissions.IsCollectionTypeAdmin | IsSpecialUser),
],
utils.Actions.DESTROY: [
IsAuthenticated,
permissions.IsCreator | IsAdmin,
],
'vote': [
IsAuthenticated,
(permissions.IsCreator | permissions.HasVotePermission
| IsCurator | IsAdmin),
],
'votes': [
IsAuthenticated,
(permissions.IsCreator | permissions.HasViewPermission
| permissions.IsCollectionAdmin
| permissions.IsCollectionTypeAdmin | IsSpecialUser),
],
'add_type': [IsAuthenticated, IsAdmin],
},
default=IsAuthenticated)
def get_object(self):
annotation_id = self.kwargs['pk']
annotation = get_object_or_404(models.Annotation, pk=annotation_id)
self.check_object_permissions(self.request, annotation)
return annotation
def get_serializer_context(self):
context = super().get_serializer_context()
try:
annotation = self.get_object()
except (KeyError, AssertionError, AttributeError):
annotation = None
context['annotation'] = annotation
return context
def get_queryset(self):
if self.action == 'votes':
annotation_id = self.kwargs['pk']
return models.AnnotationVote.objects.filter(
annotation=annotation_id)
if self.action == 'types':
return models.AnnotationType.objects.all()
if self.action == 'tools':
return models.AnnotationTool.objects.all()
if self.action == utils.Actions.LIST:
return self.get_list_queryset()
return super().get_queryset()
@action(detail=True,
methods=['GET'],
filterset_class=filters.annotation_votes.Filter,
search_fields=filters.annotation_votes.search_fields)
def votes(self, request, pk=None):
return self.list_related_object_view()
@votes.mapping.post
def vote(self, request, pk=None):
return self.create_related_object_view()
@action(detail=False,
methods=['GET'],
filterset_class=filters.annotation_types.Filter,
search_fields=filters.annotation_types.search_fields)
def types(self, request):
return self.list_related_object_view()
@types.mapping.post
def add_type(self, request):
return self.create_related_object_view()
@action(detail=False,
methods=['GET'],
filterset_class=filters.annotation_tools.Filter,
search_fields=filters.annotation_tools.search_fields)
def tools(self, request):
return self.list_related_object_view()
@tools.mapping.post
def add_tool(self, request):
return self.create_related_object_view()
def get_list_queryset(self):
user = self.request.user
if user.is_special:
return models.Annotation.objects.all()
collection_type_queryset = self.get_collection_type_admin_queryset(
user)
collection_admin_queryset = self.get_collection_admin_queryset(user)
view_pemission_queryset = self.get_view_permission_queryset(user)
open_queryset = self.get_open_queryset()
return open_queryset.union(collection_type_queryset,
collection_admin_queryset,
view_pemission_queryset)
def get_collection_type_admin_queryset(self, user):
return models.Annotation.objects.none()
def get_collection_admin_queryset(self, user):
return models.Annotation.objects.none()
def get_view_permission_queryset(self, user):
return models.Annotation.objects.none()
def get_open_queryset(self):
return models.Annotation.objects.none()
class DeviceViewSet(utils.CustomViewSetMixin, ModelViewSet):
queryset = models.Device.objects.all() # pylint: disable=E1101
filterset_class = filters.devices.Filter
search_fields = filters.devices.search_fields
serializer_mapping = (utils.SerializerMapping.from_module(
serializers.devices.devices).extend(
types=serializers.object_types.devices.ListSerializer,
add_type=serializers.object_types.devices.CreateSerializer,
brands=serializers.devices.brands.ListSerializer,
add_brand=serializers.devices.brands.CreateSerializer,
physical_devices=serializers.devices.physical_devices.
ListSerializer,
add_physical_device=serializers.devices.physical_devices.
CreateSerializer,
))
permission_mapping = utils.PermissionMapping(
{
utils.Actions.UPDATE: IsAdmin,
utils.Actions.DESTROY: IsAdmin,
'add_type': IsAdmin,
},
default=IsAuthenticated)
def get_queryset(self):
if self.action == 'types':
return models.DeviceType.objects.all() # pylint: disable=E1101
if self.action == 'brands':
return models.DeviceBrand.objects.all() # pylint: disable=E1101
if self.action == 'physical_devices':
# TODO: set adequate queryset for user
return models.PhysicalDevice.objects.all() # pylint: disable=E1101
return super().get_queryset()
@action(detail=False,
methods=['GET'],
filterset_class=filters.device_types.Filter,
search_fields=filters.device_types.search_fields)
def types(self, request):
return self.list_related_object_view()
@types.mapping.post
def add_type(self, request):
return self.create_related_object_view()
@action(detail=False,
methods=['GET'],
filterset_class=filters.device_brands.Filter,
search_fields=filters.device_brands.search_fields)
def brands(self, request):
return self.list_related_object_view()
@brands.mapping.post
def add_brand(self, request):
return self.create_related_object_view()
@action(detail=False,
methods=['GET'],
filterset_class=filters.physical_devices.Filter,
search_fields=filters.physical_devices.search_fields)
def physical_devices(self, request):
return self.list_related_object_view()
@physical_devices.mapping.post
def add_physical_device(self, request):
return self.create_related_object_view()
class UserViewSet(mixins.ListModelMixin, mixins.UpdateModelMixin,
mixins.CreateModelMixin, mixins.RetrieveModelMixin,
utils.CustomViewSetMixin, GenericViewSet):
queryset = models.User.objects.all() # pylint: disable=E1101
filterset_class = filters.users.Filter
search_fields = filters.users.search_fields
permission_mapping = utils.PermissionMapping(
{
utils.Actions.CREATE: IsUnauthenticated,
utils.Actions.UPDATE: [
IsAuthenticated, permissions.IsSelf | IsAdmin
], # TODO: Fix permissions
},
default=IsAuthenticated)
serializer_mapping = (utils.SerializerMapping.from_module(
serializers.users.users).extend(
items=serializers.items.items.ListSerializer,
devices=serializers.devices.physical_devices.ListSerializer,
sites=serializers.sites.ListSerializer,
roles=serializers.users.roles.ListSerializer,
sampling_events=serializers.sampling_events.sampling_events.
UserListSerializer,
add_role=serializers.users.roles.CreateSerializer,
collections=serializers.data_collections.data_collections.
ListSerializer,
institutions=serializers.users.institutions.ListSerializer,
add_institution=serializers.users.institutions.CreateSerializer,
))
def get_object(self):
user_pk = self.kwargs['pk']
user = get_object_or_404(models.User, pk=user_pk)
self.check_object_permissions(self.request, user)
return user
def get_serializer_class(self):
if self.action == 'retrieve':
try:
user = self.request.user
viewed_user = self.get_object()
if user == viewed_user or user.is_superuser:
return serializers.users.users.FullDetailSerializer
except (AssertionError, AttributeError):
return serializers.users.users.DetailSerializer
return super().get_serializer_class()
def get_queryset(self):
if self.action == 'roles':
return models.Role.objects.all() # pylint: disable=E1101
if self.action == 'institutions':
return models.Institution.objects.all() # pylint: disable=E1101
if self.action == 'items' or self.action == 'item_locations':
user_id = self.kwargs['pk']
return models.Item.objects.filter(created_by=user_id) # pylint: disable=E1101
if self.action == 'devices':
user_id = self.kwargs['pk']
return models.PhysicalDevice.objects.filter(owner=user_id) # pylint: disable=E1101
if self.action == 'sites' or self.action == 'site_locations':
user_id = self.kwargs['pk']
return models.Site.objects.filter(created_by=user_id) # pylint: disable=E1101
if self.action == 'collections':
user = self.get_object()
return user.collection_users.all()
if self.action == 'sampling_events' or self.action == 'sampling_event_locations':
user = self.get_object()
return user.sampling_event_created_by.all()
return super().get_queryset()
@action(detail=False,
methods=['GET'],
filterset_class=filters.roles.Filter,
search_fields=filters.roles.search_fields)
def roles(self, request):
return self.list_related_object_view()
@roles.mapping.post
def add_role(self, request):
return self.create_related_object_view()
@action(detail=False,
methods=['GET'],
filterset_class=filters.institutions.Filter,
search_fields=filters.institutions.search_fields)
def institutions(self, request):
return self.list_related_object_view()
@institutions.mapping.post
def add_institution(self, request):
return self.create_related_object_view()
@action(detail=True,
methods=['GET'],
filterset_class=filters.items.Filter,
search_fields=filters.items.search_fields)
def items(self, request, pk=None):
return self.list_related_object_view()
@action(detail=True,
methods=['GET'],
filterset_class=filters.physical_devices.Filter,
search_fields=filters.physical_devices.search_fields)
def devices(self, request, pk=None):
return self.list_related_object_view()
@action(detail=True,
methods=['GET'],
filterset_class=filters.sites.Filter,
search_fields=filters.sites.search_fields)
def sites(self, request, pk=None):
return self.list_related_object_view()
@action(detail=True,
methods=['GET'],
filterset_class=filters.sampling_events.Filter,
search_fields=filters.sampling_events.search_fields)
def sampling_events(self, request, pk=None):
return self.list_related_object_view()
@action(detail=True,
methods=['GET'],
filterset_class=filters.data_collections.Filter,
search_fields=filters.data_collections.search_fields)
def collections(self, request, pk=None):
return self.list_related_object_view()
@action(detail=True,
methods=['GET'],
filterset_class=filters.sites.Filter,
search_fields=filters.sites.search_fields)
def site_locations(self, request, pk=None):
queryset = self.filter_queryset(self.get_queryset())
serializer = serializers.sites.SiteLocationSerializer(queryset,
many=True,
read_only=True)
return Response(serializer.data)
@action(detail=True,
methods=['GET'],
filterset_class=filters.items.Filter,
search_fields=filters.items.search_fields)
def item_locations(self, request, pk=None):
queryset = self.filter_queryset(self.get_queryset())
serializer = serializers.sites.ItemLocationSerializer(queryset,
many=True,
read_only=True)
return Response(serializer.data)
@action(detail=True,
methods=['GET'],
filterset_class=filters.sampling_events.Filter,
search_fields=filters.sampling_events.search_fields)
def sampling_event_locations(self, request, pk=None):
queryset = self.filter_queryset(self.get_queryset())
serializer = serializers.sites.SamplingEventLocationSerializer(
queryset, many=True, read_only=True)
return Response(serializer.data)
