6713509976

Committed 31 Oct 2023 11:13PM UTC coverage: 86.773% (+0.7%) from 86.072%

Build # 6713509976

Build Type

push

github-actions

Committed by

web-flow

Commit Message

Merge pull request #699 from TOMToolkit/dev

Multi-Feature Merge. Please Review Carefully.

Run Details

795 of 795 new or added lines in 39 files covered. (100.0%)

8253 of 9511 relevant lines covered (86.77%)

0.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.73

/tom_dataproducts/serializers.py

from django.conf import settings
from django.contrib.auth.models import Group
from guardian.shortcuts import assign_perm, get_groups_with_perms
from rest_framework import serializers

from tom_common.serializers import GroupSerializer
from tom_dataproducts.models import DataProductGroup, DataProduct, ReducedDatum
from tom_observations.models import ObservationRecord
from tom_observations.serializers import ObservationRecordFilteredPrimaryKeyRelatedField
from tom_targets.models import Target
from tom_targets.serializers import TargetFilteredPrimaryKeyRelatedField


class DataProductGroupSerializer(serializers.ModelSerializer):
    class Meta:
        model = DataProductGroup
        fields = ('name', 'created', 'modified')


class ReducedDatumSerializer(serializers.ModelSerializer):
    target = TargetFilteredPrimaryKeyRelatedField(queryset=Target.objects.all())

    class Meta:
        model = ReducedDatum
        fields = (
            'data_product',
            'data_type',
            'source_name',
            'source_location',
            'timestamp',
            'value',
            'target'
        )

    def create(self, validated_data):
        """DRF requires explicitly handling writeable nested serializers,
        here we pop the groups data and save it using its serializer.
        """
        groups = validated_data.pop('groups', [])

        rd = ReducedDatum(**validated_data)
        rd.full_clean()
        rd.save()

        # Save groups for this target
        group_serializer = GroupSerializer(data=groups, many=True)
        if group_serializer.is_valid() and settings.TARGET_PERMISSIONS_ONLY is False:
            for group in groups:
                group_instance = Group.objects.get(pk=group['id'])
                assign_perm('tom_dataproducts.view_dataproduct', group_instance, rd)
                assign_perm('tom_dataproducts.change_dataproduct', group_instance, rd)
                assign_perm('tom_dataproducts.delete_dataproduct', group_instance, rd)

        return rd


class DataProductSerializer(serializers.ModelSerializer):
    target = TargetFilteredPrimaryKeyRelatedField(queryset=Target.objects.all())
    observation_record = ObservationRecordFilteredPrimaryKeyRelatedField(queryset=ObservationRecord.objects.all(),
                                                                         required=False)
    groups = GroupSerializer(many=True, required=False)
    data_product_group = DataProductGroupSerializer(many=True, required=False)
    reduceddatum_set = ReducedDatumSerializer(many=True, required=False)
    data_product_type = serializers.CharField(allow_blank=False)

    class Meta:
        model = DataProduct
        fields = (
            'id',
            'product_id',
            'target',
            'observation_record',
            'data',
            'extra_data',
            'data_product_type',
            'groups',
            'data_product_group',
            'reduceddatum_set'
        )

    def create(self, validated_data):
        """DRF requires explicitly handling writeable nested serializers,
        here we pop the groups data and save it using its serializer.
        """

        groups = validated_data.pop('groups', [])

        dp = DataProduct.objects.create(**validated_data)

        # Save groups for this target
        group_serializer = GroupSerializer(data=groups, many=True)
        if group_serializer.is_valid() and settings.TARGET_PERMISSIONS_ONLY is False:
            for group in groups:
                group_instance = Group.objects.get(pk=group['id'])
                assign_perm('tom_dataproducts.view_dataproduct', group_instance, dp)
                assign_perm('tom_dataproducts.change_dataproduct', group_instance, dp)
                assign_perm('tom_dataproducts.delete_dataproduct', group_instance, dp)

        return dp

    def to_representation(self, instance):
        representation = super().to_representation(instance)
        groups = []
        for group in get_groups_with_perms(instance):
            groups.append(GroupSerializer(group).data)
        representation['groups'] = groups
        return representation

    def update(self, instance, validated_data):
        groups = validated_data.pop('groups', [])

        super().save(instance, validated_data)

        # Save groups for this dataproduct
        group_serializer = GroupSerializer(data=groups, many=True)
        if group_serializer.is_valid() and not settings.TARGET_PERMISSIONS_ONLY:
            for group in groups:
                group_instance = Group.objects.get(pk=group['id'])
                assign_perm('tom_dataproducts.view_dataproduct', group_instance, instance)
                assign_perm('tom_dataproducts.change_dataproduct', group_instance, instance)
                assign_perm('tom_dataproducts.delete_dataproduct', group_instance, instance)

        return instance

    def validate_data_product_type(self, value):
        for dp_type in settings.DATA_PRODUCT_TYPES.keys():
            if not value or value == dp_type:
                break
        else:
            raise serializers.ValidationError('Not a valid data_product_type. Valid data_product_types are {0}.'
                                              .format(', '.join(k for k in settings.DATA_PRODUCT_TYPES.keys())))
        return value

1	from django.conf import settings	1✔
2	from django.contrib.auth.models import Group	1✔
3	from guardian.shortcuts import assign_perm, get_groups_with_perms	1✔
4	from rest_framework import serializers	1✔
5
6	from tom_common.serializers import GroupSerializer	1✔
7	from tom_dataproducts.models import DataProductGroup, DataProduct, ReducedDatum	1✔
8	from tom_observations.models import ObservationRecord	1✔
9	from tom_observations.serializers import ObservationRecordFilteredPrimaryKeyRelatedField	1✔
10	from tom_targets.models import Target	1✔
11	from tom_targets.serializers import TargetFilteredPrimaryKeyRelatedField	1✔
12
13
14	class DataProductGroupSerializer(serializers.ModelSerializer):	1✔
15	class Meta:	1✔
16	model = DataProductGroup	1✔
17	fields = ('name', 'created', 'modified')	1✔
18
19
20	class ReducedDatumSerializer(serializers.ModelSerializer):	1✔
21	target = TargetFilteredPrimaryKeyRelatedField(queryset=Target.objects.all())	1✔
22
23	class Meta:	1✔
24	model = ReducedDatum	1✔
25	fields = (	1✔
26	'data_product',
27	'data_type',
28	'source_name',
29	'source_location',
30	'timestamp',
31	'value',
32	'target'
33	)
34
35	def create(self, validated_data):	1✔
36	"""DRF requires explicitly handling writeable nested serializers,
37	here we pop the groups data and save it using its serializer.
38	"""
39	groups = validated_data.pop('groups', [])	1✔
40
41	rd = ReducedDatum(**validated_data)	1✔
42	rd.full_clean()	1✔
43	rd.save()	1✔
44
45	# Save groups for this target
46	group_serializer = GroupSerializer(data=groups, many=True)	1✔
47	if group_serializer.is_valid() and settings.TARGET_PERMISSIONS_ONLY is False:	1✔
48	for group in groups:	×
49	group_instance = Group.objects.get(pk=group['id'])	×
50	assign_perm('tom_dataproducts.view_dataproduct', group_instance, rd)	×
51	assign_perm('tom_dataproducts.change_dataproduct', group_instance, rd)	×
52	assign_perm('tom_dataproducts.delete_dataproduct', group_instance, rd)	×
53
54	return rd	1✔
55
56
57	class DataProductSerializer(serializers.ModelSerializer):	1✔
58	target = TargetFilteredPrimaryKeyRelatedField(queryset=Target.objects.all())	1✔
59	observation_record = ObservationRecordFilteredPrimaryKeyRelatedField(queryset=ObservationRecord.objects.all(),	1✔
60	required=False)
61	groups = GroupSerializer(many=True, required=False)	1✔
62	data_product_group = DataProductGroupSerializer(many=True, required=False)	1✔
63	reduceddatum_set = ReducedDatumSerializer(many=True, required=False)	1✔
64	data_product_type = serializers.CharField(allow_blank=False)	1✔
65
66	class Meta:	1✔
67	model = DataProduct	1✔
68	fields = (	1✔
69	'id',
70	'product_id',
71	'target',
72	'observation_record',
73	'data',
74	'extra_data',
75	'data_product_type',
76	'groups',
77	'data_product_group',
78	'reduceddatum_set'
79	)
80
81	def create(self, validated_data):	1✔
82	"""DRF requires explicitly handling writeable nested serializers,
83	here we pop the groups data and save it using its serializer.
84	"""
85
86	groups = validated_data.pop('groups', [])	1✔
87
88	dp = DataProduct.objects.create(**validated_data)	1✔
89
90	# Save groups for this target
91	group_serializer = GroupSerializer(data=groups, many=True)	1✔
92	if group_serializer.is_valid() and settings.TARGET_PERMISSIONS_ONLY is False:	1✔
93	for group in groups:	×
94	group_instance = Group.objects.get(pk=group['id'])	×
95	assign_perm('tom_dataproducts.view_dataproduct', group_instance, dp)	×
96	assign_perm('tom_dataproducts.change_dataproduct', group_instance, dp)	×
97	assign_perm('tom_dataproducts.delete_dataproduct', group_instance, dp)	×
98
99	return dp	1✔
100
101	def to_representation(self, instance):	1✔
102	representation = super().to_representation(instance)	1✔
103	groups = []	1✔
104	for group in get_groups_with_perms(instance):	1✔
105	groups.append(GroupSerializer(group).data)	×
106	representation['groups'] = groups	1✔
107	return representation	1✔
108
109	def update(self, instance, validated_data):	1✔
110	groups = validated_data.pop('groups', [])	×
111
112	super().save(instance, validated_data)	×
113
114	# Save groups for this dataproduct
115	group_serializer = GroupSerializer(data=groups, many=True)	×
116	if group_serializer.is_valid() and not settings.TARGET_PERMISSIONS_ONLY:	×
117	for group in groups:	×
118	group_instance = Group.objects.get(pk=group['id'])	×
119	assign_perm('tom_dataproducts.view_dataproduct', group_instance, instance)	×
120	assign_perm('tom_dataproducts.change_dataproduct', group_instance, instance)	×
121	assign_perm('tom_dataproducts.delete_dataproduct', group_instance, instance)	×
122
123	return instance	×
124
125	def validate_data_product_type(self, value):	1✔
126	for dp_type in settings.DATA_PRODUCT_TYPES.keys():	1✔
127	if not value or value == dp_type:	1✔
128	break	1✔
129	else:
130	raise serializers.ValidationError('Not a valid data_product_type. Valid data_product_types are {0}.'	1✔
131	.format(', '.join(k for k in settings.DATA_PRODUCT_TYPES.keys())))
132	return value	1✔

TOMToolkit / tom_base / 6713509976

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous