def run_validation(self, data=empty):
try:
self.validate_data(data['data'])
except self.Meta.ValidationError as error:
raise ValidationError(format_error_message(error))
except MultiValueDictKeyError as error:
if 'data' in str(error):
msg = format_error_message('Data key not present')
raise ValidationError(msg)
raise ValidationError(format_error_message(error))
# only validate data updatint, not creating
if (self.context['request'].method != 'POST'):
try:
try:
fields_to_validate = self.Meta.metadata_validation_fields
except AttributeError:
fields_to_validate = None
if fields_to_validate:
validate_metadata_data(
data['metadata'],
fields_to_validate=fields_to_validate)
except MetadataValidationError as error:
raise ValidationError(format_error_message(error))
return data
def serialize_observation_images_from_request(request, tmp_extract_dir):
conf = None
if 'multipart/form-data' in request.content_type:
create_observation_units = request.data.get(CREATE_OBSERVATION_UNITS,
None)
zip_file = request.FILES['file'].file
logger.debug(type(request.FILES['file']))
logger.debug(request.FILES['file'].name)
logger.debug(dir(request.FILES['file']))
logger.debug(type(zip_file))
logger.debug(dir(zip_file))
try:
data = list(
extract_files_from_zip(zip_file,
extract_dir=tmp_extract_dir,
make_group_writable=True))
except ValueError as error:
raise ValidationError(format_error_message(error))
conf = {
CREATE_OBSERVATION_UNITS: create_observation_units,
'extraction_dir': tmp_extract_dir
}
else:
msg = 'Request must be a multipart/form-data request with at least a zip file'
raise ValidationError(format_error_message(msg))
return data, conf
def bulk(self, request):
action = request.method
# prev_time = time()
data = request.data
if 'multipart/form-data' in request.content_type:
try:
fhand = request.FILES['file'].file
except KeyError:
msg = 'could not found the file'
raise ValidationError(format_error_message(msg))
try:
data = serialize_entity_from_excel(fhand, self.Struct)
except ValueError as error:
msg = 'Could not read file: {}'.format(error)
raise ValidationError(format_error_message(msg))
else:
data = request.data
if action == 'POST':
serializer = self.get_serializer(data=data, many=True)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
return Response({'task_id': serializer.instance.id},
status=status.HTTP_200_OK,
headers={})
def update_study_in_db(validated_data, instance, user):
study_struct = StudyStruct(api_data=validated_data)
if (study_struct.name != instance.name):
msg = 'Can not change id in an update operation'
raise ValidationError(format_error_message(msg))
group_belong_to_user = bool(user.groups.filter(name=study_struct.metadata.group).count())
if not group_belong_to_user and not is_user_admin(user):
msg = 'Can not change ownership if group does not belong to you : {}'
msg = msg.format(study_struct.metadata.group)
raise ValidationError(format_error_message(msg))
try:
group = Group.objects.get(name=study_struct.metadata.group)
except Group.DoesNotExist:
msg = 'Provided group does not exist in db: {}'
msg = msg.format(study_struct.metadata.group)
raise ValidationError(format_error_message(msg))
instance.description = study_struct.description
instance.is_active = study_struct.is_active
instance.group = group
instance.is_public = study_struct.metadata.is_public
instance.data = study_struct.data
instance.start_date = study_struct.start_date
instance.end_date = study_struct.end_date
instance.save()
return instance
def update_accessionset_in_db(payload, instance, user):
struct = AccessionSetStruct(payload)
allowed_changes = set(['is_public', 'group'])
changes_in_payload = set()
if instance.institute.code != struct.institute_code:
changes_in_payload.add('institute')
if instance.accessionset_number != struct.accessionset_number:
changes_in_payload.add('accessionset_number')
db_accessions = set([(accession.institute.code, accession.germplasm_number)
for accession in instance.accessions.all()])
payload_accessions = set([(accession[INSTITUTE_CODE],
accession[GERMPLASM_NUMBER])
for accession in struct.accessions])
are_payload_accessions_diff = bool(
db_accessions.difference(payload_accessions))
if are_payload_accessions_diff:
changes_in_payload.add('accessions')
if instance.is_public != struct.metadata.is_public:
changes_in_payload.add('is_public')
if instance.group != struct.metadata.group:
changes_in_payload.add('group')
not_allowed_changes = changes_in_payload.difference(allowed_changes)
if not_allowed_changes:
msg = "you are not allowed to change accessionsets's: {}"
msg = msg.format(','.join(not_allowed_changes))
raise ValidationError(format_error_message(msg))
group_belong_to_user = bool(
user.groups.filter(name=struct.metadata.group).count())
if not group_belong_to_user and not is_user_admin(user):
msg = 'Can not change ownership if group does not belong to you : {}'
msg = msg.format(struct.metadata.group)
raise ValidationError(format_error_message(msg))
try:
group = Group.objects.get(name=struct.metadata.group)
except Group.DoesNotExist:
msg = 'Provided group does not exist in db: {}'
msg = msg.format(struct.metadata.group)
raise ValidationError(format_error_message(msg))
instance.is_public = struct.metadata.is_public
instance.owner = group
instance.save()
return instance
def retrieve(self, request, task_id):
try:
task_id = self.filter_by_permission([task_id],
user=request.user)[0]
except IndexError:
return Response(format_error_message('Task does not exists'),
status=status.HTTP_404_NOT_FOUND)
try:
task = TaskResultGetter(task_id)
except TaskDoesNotExistError:
return Response(format_error_message('Task does not exists'),
status=status.HTTP_404_NOT_FOUND)
return Response(task.data, status=status.HTTP_200_OK)
def _check_observation_variable_in_filter(self):
if 'observation_variable' not in self.data.keys():
msg = 'Can not use value_range filter if not filtered by observation variable'
raise ValidationError(format_error_message(msg))
try:
observation_variable = ObservationVariable.objects.get(
name=self.data['observation_variable'])
except ObservationVariable.DoesNotExist:
msg = 'Used observation_variable to filter does not exist'
raise ValidationError(format_error_message(msg))
if observation_variable.scale.data_type.name not in ('Numerical', ):
msg = "Used observation_variable's data type is not numeric"
raise ValidationError(format_error_message(msg))
def _populate_with_instance(self, instance, fields):
self.metadata.group = instance.group.name
self.metadata.is_public = instance.is_public
accepted_fields = STUDY_ALLOWED_FIELDS
if (fields is not None and
len(set(fields).intersection(accepted_fields)) == 0):
msg = format_error_message('Passed fields are not allowed')
raise ValidationError(msg)
if fields is None or STUDY_NAME in fields:
self.name = instance.name
if fields is None or STUDY_DESCRIPTION in fields:
self.description = instance.description
if instance.is_active is not None and fields is not None and STUDY_ACTIVE in fields:
self.is_active = instance.is_active
if fields is None or START_DATE in fields:
if instance.start_date is not None:
self.start_date = instance.start_date.strftime('%Y/%m/%d')
else:
self.start_date = None
if fields is None or END_DATE in fields:
if instance.end_date is not None:
self.end_date = instance.end_date.strftime('%Y/%m/%d')
else:
self.end_date = None
if fields is None or LOCATION in fields:
self.location = instance.data.get(LOCATION, None)
if fields is None or CONTACT in fields:
self.contact = instance.data.get(CONTACT, None)
if fields is None or PROJECT_NAME in fields:
self.project_name = instance.data.get(PROJECT_NAME, None)
if fields is None or SEASON in fields:
self.season = instance.data.get(SEASON, None)
if fields is None or INSTITUTION in fields:
self.institution = instance.data.get(INSTITUTION, None)
def bulk(self, request):
action = request.method
# prev_time = time()
data = request.data
if 'multipart/form-data' in request.content_type:
try:
fhand = request.FILES['file'].file
data_source_code = request.data['data_source_code']
data_source_kind = request.data['data_source_kind']
except KeyError:
msg = 'Could not found excel file or data_store info'
raise ValidationError(msg)
try:
data = serialize_accessions_from_excel(fhand, data_source_code,
data_source_kind)
except AccessionValidationError as error:
raise ValidationError(format_error_message(error))
else:
data = request.data
# prev_time = calc_duration('csv to json', prev_time)
if action == 'POST':
serializer = self.get_serializer(data=data, many=True)
# prev_time = calc_duration('get_serializer', prev_time)
try:
serializer.is_valid(raise_exception=True)
except BaseException as errors:
errors = [error for error in errors.detail if error]
raise ValidationError(errors)
self.perform_create(serializer)
# prev_time = calc_duration('perform_create', prev_time)
return Response({'task_id': serializer.instance.id},
status=status.HTTP_200_OK,
headers={})
def update(self, instance, validated_data):
user = None
request = self.context.get("request")
if request and hasattr(request, "user"):
user = request.user
if user is None:
error = 'User must be logged'
raise ValidationError(format_error_message(error))
if not user.groups.exists():
error = 'User must belong to a group'
raise ValidationError(format_error_message(error))
try:
return update_institute_in_db(validated_data, instance)
except ValueError as error:
raise ValidationError(format_error_message(error))
def toggle_public(self, request):
try:
is_public = request.data['public']
search_params = request.data['search_params']
except KeyError:
msg = 'public and search_params keys are mandatory to toogle publc state'
raise ValidationError(format_error_message(msg))
queryset = self.filter_queryset(self.get_queryset())
filterset = self.filter_class(search_params, queryset)
filterset.qs.update(is_public=is_public)
msg = "{} {} made {}".format(filterset.qs.count(),
self.serializer_class.data_type,
'public' if is_public else 'private')
return Response(format_error_message(msg), status=status.HTTP_200_OK)
def _populate_with_instance(self, instance, fields):
accepted_fields = OBSERVATION_ALLOWED_FIELDS
if (fields is not None and not set(fields).intersection(accepted_fields)):
msg = format_error_message('Passed fields are not allowed')
raise ValidationError(msg)
if ((fields is None or OBSERVATION_ID in fields) and
instance.observation_id is not None):
self.observation_id = instance.observation_id
if ((fields is None or OBSERVATION_VARIABLE in fields) and
instance.observation_unit is not None):
self.observation_variable = instance.observation_variable.name
if ((fields is None or OBSERVATION_UNIT in fields) and
instance.observation_unit is not None):
self.observation_unit = instance.observation_unit.name
if (fields is None or VALUE in fields) and instance.value is not None:
self.value = instance.value
if (fields is None or OBSERVER in fields) and instance.observer is not None:
self.observer = instance.observer
if ((fields is None or OBSERVATION_CREATION_TIME in fields) and
instance.creation_time is not None):
self.creation_time = instance.creation_time.strftime(DATETIME_FORMAT)
if ((fields is None or OBSERVATION_STUDY in fields) and
instance.observation_unit is not None and
instance.observation_unit.study is not None):
self.study = instance.observation_unit.study.name
if ((fields is None or ACCESSION in fields) and
instance.observation_unit is not None and
instance.observation_unit.accession is not None):
self.accession = {INSTITUTE_CODE: instance.observation_unit.accession.institute.code,
GERMPLASM_NUMBER: instance.observation_unit.accession.germplasm_number}
if instance.beauty_value and fields and VALUE_BEAUTY in fields:
self.beauty_value = instance.beauty_value
def check_before_remove(self, instance):
if Observation.objects.filter(
observation_unit__accession=instance).count():
msg = 'Can not delete this accession because there are observations'
msg += ' associated to it'
return Response(format_error_message(msg),
status=status.HTTP_400_BAD_REQUEST)
def create(self, validated_data):
user = None
request = self.context.get("request")
if request and hasattr(request, "user"):
user = request.user
if user is None:
error = 'User must be logged'
raise ValidationError(format_error_message(error))
if not user.groups.exists():
error = 'User must belong to a group'
raise ValidationError(format_error_message(error))
async_result = create_institutes_task.delay(validated_data)
# async_result = wait_func.delay(5)
add_task_to_user(user, async_result)
return async_result
def bulk(self, request):
action = request.method
# prev_time = time()
with tempfile.TemporaryDirectory(dir=TMP_DIR) as tmp_dir:
extract_dir = tmp_dir
if 'multipart/form-data' in request.content_type:
create_observation_units = request.data.get(
CREATE_OBSERVATION_UNITS, None)
fhand = request.FILES['file']
logger.debug('1')
with tempfile.NamedTemporaryFile(mode='wb',
suffix='.zip',
dir=TMP_DIR) as destination:
for chunk in fhand.chunks():
destination.write(chunk)
destination.flush()
subprocess.run(['chmod', '777', destination.name])
task = extract_files_from_zip.apply_async(
args=[destination.name, extract_dir])
try:
data = task.wait()
add_task_to_user(self.request.user, task)
except ValueError as error:
raise ValidationError(format_error_message(str(error)))
else:
msg = 'Request must be a multipart/form-data request '
msg += 'with at least a zip file'
raise ValidationError(format_error_message(msg))
self.conf = {
CREATE_OBSERVATION_UNITS: create_observation_units,
'extraction_dir': extract_dir
}
if action == 'POST':
serializer = self.get_serializer(data=data, many=True)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
return Response({'task_id': serializer.instance.id},
status=status.HTTP_200_OK,
headers={})
def delete(self, request, task_id):
try:
task_id = self.filter_by_permission([task_id],
user=request.user)[0]
except IndexError:
return Response(format_error_message('You dont have permissions'),
status=status.HTTP_403_FORBIDDEN)
task = TaskResultGetter(task_id)
task.delete()
return Response({}, status=status.HTTP_204_NO_CONTENT)
def update_observation_unit_in_db(validated_data, instance, user):
struct = ObservationUnitStruct(api_data=validated_data)
if struct.name != instance.name:
msg = 'Can not change id in an update operation'
raise ValidationError(format_error_message(msg))
try:
study = Study.objects.get(name=struct.study)
except Study.DoesNotExist:
msg = 'The study has not been added yet to the database: ' + struct.study
raise ValueError(msg)
institute_code = struct.accession[INSTITUTE_CODE]
germplasm_number = struct.accession[GERMPLASM_NUMBER]
try:
accession = Accession.objects.get(institute__code=institute_code,
germplasm_number=germplasm_number)
except Accession.DoesNotExist:
msg = 'The given accessoin is not in db: {} {}'.format(institute_code,
germplasm_number)
raise ValueError(msg)
study_belongs_to_user = bool(user.groups.filter(name=study.group.name).count())
if not study_belongs_to_user and not is_user_admin(user):
msg = 'Can not change ownership if study does not belong to you : {}'
msg = msg.format(study.group.name)
raise ValidationError(format_error_message(msg))
instance.accession = accession
instance.level = struct.level
instance.replicate = struct.replicate
instance.study = study
instance.save()
plants = [] if struct.plants is None else struct.plants
instance.plant_set.clear()
_add_plants_to_observation_unit(plants, user, instance)
return instance
def update_scale_in_db(api_data, instance, _):
try:
struct = ScaleStruct(api_data)
except ScaleValidationError as error:
print(error)
raise
try:
data_type = ScaleDataType.objects.get(name=struct.data_type)
except ScaleDataType.DoesNotExist:
raise ValidationError(
format_error_message('data type not valid: ' + struct.data_type))
if instance.description != struct.description:
instance.description = struct.description
if instance.data_type != data_type:
instance.data_type = data_type
if instance.max != struct.max:
instance.max = struct.max
if instance.min != struct.min:
instance.min = struct.min
if instance.decimal_places != struct.decimal_places:
instance.decimal_places = struct.decimal_places
instance.save()
if struct.data_type in ('Cardinal', 'Ordinal', 'Nominal'):
ScaleCategory.objects.filter(scale=instance).delete()
for index, category in enumerate(struct.valid_values):
value = category['value']
description = category['description']
try:
ScaleCategory.objects.create(scale=instance,
value=value,
description=description,
rank=index)
except IntegrityError:
msg = 'Can not repeate value or description in the same scale'
raise ValidationError(format_error_message(msg))
return instance
def list(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
try:
data = list(serializer.data)
except ValidationError as error:
errors = [e for e in error.detail['detail']]
return Response(format_error_message(errors),
status=status.HTTP_400_BAD_REQUEST)
return self.get_paginated_response(data)
serializer = self.get_serializer(queryset, many=True)
try:
data = list(serializer.data)
except ValidationError as error:
errors = [e for e in error.detail['detail']]
return Response(format_error_message(errors),
status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.data)
def year_filter(self, queryset, _, value):
try:
if len(value) != 4:
raise ValueError('Year must be a string of 4 digits')
year = int(value)
except ValueError as error:
raise ValidationError(format_error_message(error))
year_start = date(year=year, month=1, day=1)
year_end = date(year=year, month=12, day=31)
return queryset.filter(
Q(start_date__gte=year_start, start_date__lte=year_end)
| Q(end_date__gte=year_start, end_date__lte=year_end)
| Q(start_date__lte=year_start, end_date__gte=year_end))
def create_scale_in_db(api_data, user):
try:
struct = ScaleStruct(api_data)
except ScaleValidationError as error:
print(error)
raise
try:
data_type = ScaleDataType.objects.get(name=struct.data_type)
except ScaleDataType.DoesNotExist:
raise ValidationError('data type not valid: ' + struct.data_type)
group = user.groups.first()
with transaction.atomic():
try:
scale = Scale.objects.create(name=struct.name,
description=struct.description,
data_type=data_type,
decimal_places=struct.decimal_places,
min=struct.min,
max=struct.max,
group=group)
except IntegrityError:
msg = 'This scale already exists in db: {}'.format(struct.name)
raise ValueError(format_error_message(msg))
if struct.data_type in (ORDINAL, NOMINAL):
for index, category in enumerate(struct.valid_values):
value = category['value']
description = category['description']
try:
ScaleCategory.objects.create(scale=scale,
value=value,
description=description,
rank=index)
except IntegrityError:
msg = 'Can not repeate value or description in the same scale'
raise ValidationError(format_error_message(msg))
return scale
def _populate_with_instance(self, instance, fields):
self.metadata.group = instance.group.name
self.metadata.is_public = instance.is_public
accepted_fields = [INSTITUTE_CODE, GERMPLASM_NUMBER, IS_AVAILABLE,
CONSTATUS, PASSPORTS, 'genera', 'countries',
'longitude', 'latitude', 'species',
IN_NUCLEAR_COLLECTION]
if fields is not None and not set(fields).issubset(accepted_fields):
msg = format_error_message('Passed fields are not allowed')
raise ValidationError(msg)
if fields is None or INSTITUTE_CODE in fields:
self.institute_code = instance.institute.code
if fields is None or GERMPLASM_NUMBER in fields:
self.germplasm_number = instance.germplasm_number
if (instance.is_available is not None and
(fields is None or IS_AVAILABLE in fields)):
self.is_available = instance.is_available
if (instance.conservation_status is not None and
(fields is None or CONSTATUS in fields)):
self.conservation_status = instance.conservation_status
if (instance.in_nuclear_collection is not None and
(fields is None or IN_NUCLEAR_COLLECTION in fields)):
self.in_nuclear_collection = instance.in_nuclear_collection
if instance.genera and fields and 'genera' in fields:
self.genera = instance.genera
if instance.species and fields and 'species' in fields:
self.species = instance.species
if instance.countries and fields and 'countries' in fields:
self.countries = instance.countries
if fields is None or (PASSPORTS in fields or 'latitude' in fields or 'longitude' in fields):
passports = []
passport_fields = []
if fields and 'latitude' in fields:
passport_fields.append('latitude')
if fields and 'longitude' in fields:
passport_fields.append('longitude')
if not passport_fields:
passport_fields = None
for passport_instance in instance.passports.all():
passport_struct = PassportStruct(instance=passport_instance,
fields=passport_fields)
passports.append(passport_struct)
self.passports = passports
def update_observation_variable_in_db(validated_data, instance, user):
struct = ObservationVariableStruct(api_data=validated_data)
if struct.name != instance.name:
msg = 'Can not change id in an update operation'
raise ValidationError(format_error_message(msg))
group_belong_to_user = bool(user.groups.filter(name=struct.metadata.group).count())
if not group_belong_to_user and not is_user_admin(user):
msg = 'Can not change ownership if group does not belong to you : {}'
msg = msg.format(struct.metadata.group)
raise ValidationError(format_error_message(msg))
try:
group = Group.objects.get(name=struct.metadata.group)
except Group.DoesNotExist:
msg = 'Provided group does not exist in db: {}'
msg = msg.format(struct.metadata.group)
raise ValidationError(format_error_message(msg))
try:
scale = Scale.objects.get(name=struct.scale)
except Scale.DoesNotExist:
raise ValidationError('Scale not valid: ' + struct.scale)
try:
trait = Trait.objects.get(name=struct.trait)
except Trait.DoesNotExist:
raise ValidationError('Trait not valid: ' + struct.scale)
instance.description = struct.description
instance.trait = trait
instance.group = group
instance.method = struct.method
instance.scale = scale
instance.save()
return instance
def _populate_with_instance(self, instance, fields):
accepted_fields = TRAIT_ALLOWED_FIELDS
if (fields is not None
and len(set(fields).intersection(accepted_fields)) == 0):
msg = format_error_message('Passed fields are not allowed')
raise ValidationError(msg)
if fields is None or TRAIT_NAME in fields:
self.name = instance.name
if fields is None or TRAIT_DESCRIPTION in fields:
self.description = instance.description
if fields is None or ONTOLOGY_NAME in fields:
self.ontology = instance.ontology
if fields is None or ONTOLOGY_ID in fields:
self.ontology_id = instance.ontology_id
def update_accession_in_db(validated_data, instance, user):
accession_struct = AccessionStruct(api_data=validated_data)
if (accession_struct.institute_code != instance.institute.code or
accession_struct.germplasm_number != instance.germplasm_number):
msg = 'Can not change id in an update operation'
raise ValidationError(format_error_message(msg))
group_belong_to_user = bool(user.groups.filter(name=accession_struct.metadata.group).count())
if not group_belong_to_user and not is_user_admin(user):
msg = 'Can not change ownership if group does not belong to you : {}'
msg = msg.format(accession_struct.metadata.group)
raise ValidationError(format_error_message(msg))
if not is_user_admin(user) and instance.is_public != accession_struct.metadata.is_public:
msg = 'User can not make accession public or private'
raise ValidationError(format_error_message(msg))
try:
group = Group.objects.get(name=accession_struct.metadata.group)
except Group.DoesNotExist:
msg = 'Provided group does not exist in db: {}'
msg = msg.format(accession_struct.metadata.group)
raise ValidationError(format_error_message(msg))
with transaction.atomic():
instance.is_available = accession_struct.is_available
instance.conservation_status = accession_struct.conservation_status
instance.in_nuclear_collection = accession_struct.in_nuclear_collection
instance.group = group
instance.is_public = accession_struct.metadata.is_public
instance.passports.all().delete()
for passport_struct in accession_struct.passports:
_create_passport_in_db(passport_struct, instance)
instance.save()
return instance
def update(self, instance, validated_data):
instances = []
errors = []
with transaction.atomic():
for instance, payload in zip(instance, validated_data):
try:
instances.append(update_institute_in_db(payload, instance))
except ValueError as error:
errors.append(error)
except IntegrityError as error:
errors.append(error)
if errors:
raise ValidationError(format_error_message(errors))
else:
return instances
def bulk(self, request):
action = request.method
# prev_time = time()
try:
data, conf = serialize_observations_from_request(request)
except ValueError as error:
msg = 'Could not read file: {}'.format(error)
raise ValidationError(format_error_message(msg))
self.conf = conf
if action == 'POST':
serializer = self.get_serializer(data=data, many=True)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
return Response({'task_id': serializer.instance.id},
status=status.HTTP_200_OK,
headers={})
def create_by_obo(self, request):
try:
fhand = TextIOWrapper(request.FILES['obo'].file,
encoding='utf-8')
except KeyError:
msg = 'could not found obo file'
raise ValidationError(format_error_message(msg))
ontology = parse_obo(fhand)
data = transform_to_trait_entity_format(ontology)
serializer = self.get_serializer(data=data, many=True)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
return Response({'task_id': serializer.instance.id},
status=status.HTTP_200_OK,
headers={})
def _populate_with_instance(self, instance, fields):
accepted_fields = SEED_REQUEST_ALLOWED_FIELDS
if (fields is not None
and len(set(fields).intersection(accepted_fields)) == 0):
msg = format_error_message('Passed fields are not allowed')
raise ValidationError(msg)
if fields is None or REQUEST_UID in fields:
self.request_uid = instance.request_uid
if fields is None or REQUESTER_NAME in fields:
self.requester_name = instance.requester_name
if fields is None or REQUESTER_TYPE in fields:
self.requester_type = instance.requester_type
if fields is None or REQUESTER_INSTITUTION in fields:
self.requester_institution = instance.requester_institution
if fields is None or REQUESTER_ADDRESS in fields:
self.requester_address = instance.requester_address
if fields is None or REQUESTER_CITY in fields:
self.requester_city = instance.requester_city
if fields is None or REQUESTER_POSTAL_CODE in fields:
self.requester_postal_code = instance.requester_postal_code
if fields is None or REQUESTER_REGION in fields:
self.requester_region = instance.requester_region
if fields is None or REQUESTER_COUNTRY in fields:
self.requester_country = instance.requester_country.code
if fields is None or REQUESTER_EMAIL in fields:
self.requester_email = instance.requester_email
if fields is None or REQUEST_DATE in fields:
self.request_date = instance.request_date.strftime('%Y/%m/%d')
if fields is None or REQUEST_AIM in fields:
self.request_aim = instance.request_aim
if fields is None or REQUEST_COMMENTS in fields:
self.request_comments = instance.request_comments
if fields is None or REQUESTED_ACCESSIONS in fields:
accessions = []
for accession_instance in instance.requested_accessions.all():
accessions.append({
INSTITUTE_CODE:
accession_instance.institute.code,
GERMPLASM_NUMBER:
accession_instance.germplasm_number
})
self.requested_accessions = accessions
def __init__(self, *args, **kwargs):
# Don't pass the 'fields' arg up to the superclass
fields = kwargs.pop('fields', None)
# Instantiate the superclass normally
super(serializers.ModelSerializer, self).__init__(*args, **kwargs)
if fields is not None:
# Drop any fields that are not specified in the `fields` argument.
if not set(fields).issubset(self.fields):
raise ValidationError(
format_error_message('Passed fields are not allowed'))
allowed = set(fields)
existing = set(self.fields)
for field_name in existing - allowed:
self.fields.pop(field_name)
else:
self.fields.pop('stats_by_institute')
self.fields.pop('stats_by_taxa')