class TicketSerializer(serializers.ModelSerializer):
id = serializers.CharField()
activation_link = serializers.SerializerMethodField()
scanned = serializers.BooleanField(read_only=True)
included_serializers = {
'offline_lecture': OfflineLectureSerializer,
}
customer_email = serializers.EmailField(source='customer.email')
offline_lecture_id = serializers.CharField(source='offline_lecture.id')
offline_lecture = serializers.ResourceRelatedField(read_only=True)
class Meta:
model = Ticket
fields = [
'id',
'customer_email',
'activation_link',
'offline_lecture',
'scanned',
'offline_lecture_id',
]
def get_activation_link(self, obj):
if obj.get_qr_code():
return f"{settings.SITE_URL}/api/tickets/activate/{obj.qrcode.code}"
return ""
def create(self, validated_data):
customer = validated_data.get('customer')
offline_lecture = validated_data.get('offline_lecture')
customer = User.objects.get(email=customer.get('email'))
offline_lecture = OfflineLecture.objects.get(
id=offline_lecture.get('id'))
return Ticket.objects.create(customer=customer,
offline_lecture=offline_lecture)
class VideoSerializer(serializers.Serializer):
dependency_count = serializers.SerializerMethodField()
duration = serializers.IntegerField()
license_name = serializers.SerializerMethodField()
license_url = serializers.SerializerMethodField()
name = serializers.CharField(max_length=100)
url = serializers.URLField()
stream_url = serializers.URLField()
image_url = serializers.URLField()
provider_name = serializers.CharField(max_length=100)
tags = serializers.SerializerMethodField()
def get_dependency_count(self, obj):
data = self.context.get(obj.id)
if data:
return data.get('dep_count', 0)
return 0
def get_license_name(self, obj):
value = obj.license_name
if value is None or len(value) == 0:
return None
return value
def get_license_url(self, obj):
value = obj.license_url
if value is None or len(value) == 0:
return None
return value
def get_tags(self, obj):
sorted_categories = sorted(
obj.categories,
key=lambda cat: obj.categories.get(cat, 'weight', default=0))
return ','.join([cat.name for cat in sorted_categories])
class ChangePasswordSerializer(serializers.Serializer):
"""
When a user is logged in, allow them to change their own password
"""
current_password = serializers.CharField()
confirm_password = serializers.CharField()
password = serializers.CharField()
user = serializers.PrimaryKeyRelatedField(
queryset=User.objects.get_queryset()
)
def validate(self, data):
# Check current password
if not data['user'].check_password(data['current_password']):
raise serializers.ValidationError(
'Current password is not correct'
)
# Perform server side validation
if data['password'] != data['confirm_password']:
raise serializers.ValidationError(
'Password and Confirm Password should be the same'
)
return data
def save(self, **kwargs):
user = self.validated_data['user']
user.set_password(self.validated_data['password'])
user.save()
return True
class Meta:
model = User
class FileSerializer(BaseInternalModelSerializer):
file = RemoteFileField()
organization = ResourceRelatedField(many=False,
queryset=Organization.objects)
group = ResourceRelatedField(many=False,
queryset=Group.objects,
required=False)
user = ResourceRelatedField(many=False, queryset=get_user_model().objects)
user_path = serializers.CharField(allow_blank=True,
required=False,
allow_null=True)
description = serializers.CharField(allow_blank=True,
required=False,
allow_null=True)
class Meta:
model = File
fields = ('id', 'metadata', 'created', 'modified', 'visibility',
'user_path', 'organization', 'user', 'name', 'file',
'description', 'group', 'preview_url')
read_only_fields = ('id', 'preview_url')
def save(self, **kwargs):
super().save()
request_filepreview.delay(file_id=str(self.instance.id),
url=self.instance.file.url)
class UserSerializer(serializers.ModelSerializer):
lastname = serializers.CharField(source='last_name')
firstname = serializers.CharField(source='first_name')
issuperuser = serializers.CharField(source='is_superuser')
class Meta:
resource_name = 'users'
model = User
fields = ('id', 'username', 'lastname', 'firstname', 'email', 'issuperuser')
class KeywordedResponseSerializer(serializers.ModelSerializer):
class Meta:
model = KeywordedResponse
fields = '__all__'
id = serializers.IntegerField(read_only=True)
keyword = serializers.CharField(read_only=True)
response = serializers.CharField(read_only=True)
class IgnoreNumberSerializer(serializers.ModelSerializer):
class Meta:
model = IgnoreNumber
fields = '__all__'
id = serializers.IntegerField(read_only=True)
number = serializers.CharField(read_only=True)
note = serializers.CharField(read_only=True)
class NewMemberNoticeSerializer(serializers.ModelSerializer):
class Meta:
model = NewMemberNotice
fields = '__all__'
id = serializers.IntegerField(read_only=True)
title = serializers.CharField(read_only=True)
response = serializers.CharField(read_only=True)
class AuthorSerializer(serializers.ModelSerializer):
id = serializers.IntegerField()
name = serializers.CharField(max_length=50)
email = serializers.CharField(max_length=30)
class Meta:
model = Author
fields = '__all__'
class NotifySerializer(serializers.Serializer):
from_email = serializers.EmailField(max_length=200, required=True)
subject = serializers.CharField(max_length=500, required=True)
message = serializers.CharField(max_length=1000, required=True)
is_consent = serializers.BooleanField(default=False, required=False)
def create(self, validated_data):
"""Create an RT ticket.
If this is a consent approval then the procedure is:
- create ticket in ENA-MG queue
otherwise:
- create ticket in EMG queue
"""
import requests
n = ena_models.Notify(**validated_data)
emg_queue = settings.RT["emg_queue"]
ena_queue = settings.RT["ena_queue"]
ticket = {
"id": "ticket/new",
"Requestor": n.from_email,
"Priority": "4",
"Subject": n.subject,
"Text": n.message.replace("\n", ';')
}
if n.is_consent:
ticket["Queue"] = ena_queue
else:
ticket["Queue"] = emg_queue
logger.info("Ticket %r" % ticket)
content = [
"{key}: {value}".format(
key=key, value=value) for key, value in ticket.items()
]
payload = {
'user': settings.RT['user'],
'pass': settings.RT['pass'],
'content': "\n".join(content),
}
headers = {
'Content-Type': 'application/x-www-form-urlencoded'
}
r = requests.post(settings.RT['url'], data=payload, headers=headers)
return r.status_code
class Meta:
model = ena_models.Notify
fields = '__all__'
class UserSerializer(serializers.ModelSerializer):
"""Users serializer."""
current_password = serializers.CharField(write_only=True, required=False)
password = serializers.CharField(write_only=True, required=False)
class Meta:
"""Serializer meta information."""
model = User
fields = ["email", "password", "current_password"]
def create(self, validated_data):
"""Create the user with the given email and password."""
user = User.objects.create_user(validated_data["email"],
validated_data["password"])
return user
def update(self, instance, validated_data):
"""Set the password on the instance."""
if "password" in validated_data:
instance.set_password(validated_data.pop("password"))
return super().update(instance, validated_data)
def validate(self, attrs):
"""Validate data."""
attrs = super().validate(attrs)
# creating
if self.instance is None:
if "password" not in attrs:
msg = _("This field is required when creating a new user.")
raise ValidationError({"password": msg})
# updating
else:
# cannot update email address
attrs.pop("email", None)
# when changing password validate current_password
if "password" in attrs:
if "current_password" not in attrs:
msg = _(
"This field is required when changing your password.")
raise ValidationError({"current_password": msg})
if not self.instance.check_password(attrs["current_password"]):
msg = _("Your current password is incorrect.")
raise ValidationError({"current_password": msg})
# validate the password if it is included
if "password" in attrs:
self._validate_password(attrs["password"])
return attrs
def _validate_password(self, password): # pylint: disable=no-self-use
try:
validate_password(password)
except DjangoValidationError as error:
raise ValidationError({"password": error.messages})
class TokenProxySerializer(serializers.ModelSerializer):
username = serializers.CharField(write_only=True, required=False)
password = serializers.CharField(write_only=True, required=False)
municipality = serializers.IntegerField(required=False)
token = serializers.SerializerMethodField()
def get_token(self, obj):
client = HousingStatClient()
token_resp = client.get_token(username=obj.username,
password=obj.password)
if token_resp["success"] is True:
return token_resp["token"]
raise ValidationError({
token_resp["status_code"]: {
"source": "external",
"reason": token_resp["reason"],
}
})
def create(self, validated_data):
user = self.context["request"].user
username = validated_data.get("username")
password = validated_data.get("password")
municipality = validated_data.get("municipality")
if username and password and municipality:
user_creds, _ = models.HousingStatCreds.objects.update_or_create(
owner=user.username,
defaults={
"username": username,
"password": password,
"municipality": municipality,
},
)
else:
user_creds = models.HousingStatCreds.objects.filter(
owner=user.username)
user_creds.update(**validated_data)
user_creds = user_creds.first()
if not user_creds:
raise ValidationError({
400: {
"source":
"internal",
"reason":
f'No housing stat credentials found for user "{user.username}"',
}
})
return user_creds
class Meta:
model = models.HousingStatCreds
fields = ("username", "password", "token", "municipality")
class UserSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(read_only=True)
first_name = serializers.CharField(read_only=True)
last_name = serializers.CharField(read_only=True)
class Meta:
model = User
fields = [
"id", "first_name", "last_name", "available_from", "available_to",
"facebook_link", "interests"
]
read_only_fields = ["id", "first_name", "last_name", "facebook_link"]
class SubmitterSerializer(serializers.Serializer):
first_name = serializers.CharField(max_length=30)
surname = serializers.CharField(max_length=50)
email_address = serializers.CharField(max_length=200)
analysis = serializers.BooleanField(default=False)
submitter = serializers.BooleanField(default=False)
class Meta:
model = ena_models.Submitter
fields = '__all__'
class UserSerializer(serializers.Serializer):
id = serializers.CharField(read_only=True)
username = serializers.CharField()
email = serializers.EmailField()
class Meta:
model = User
class JSONAPIMeta:
resource_name = 'users'
def create(self, validated_data):
return User.objects.create_user(password='******', **validated_data)
class EntrySerializer(serializers.Serializer):
blog = serializers.IntegerField()
comments = CommentSerializer(many=True, required=False)
comment = CommentSerializer(required=False)
headline = serializers.CharField(allow_null=True, required=True)
body_text = serializers.CharField()
def validate(self, attrs):
body_text = attrs['body_text']
if len(body_text) < 5:
raise serializers.ValidationError({'body_text': {
'title': 'Too Short title', 'detail': 'Too short'}
})
class EntrySerializer(serializers.Serializer):
blog = serializers.IntegerField()
comments = CommentSerializer(many=True, required=False)
comment = CommentSerializer(required=False)
headline = serializers.CharField(allow_null=True, required=True)
body_text = serializers.CharField()
def validate(self, attrs):
body_text = attrs["body_text"]
if len(body_text) < 5:
raise serializers.ValidationError(
{"body_text": {"title": "Too Short title", "detail": "Too short"}}
)
class EmailSerializer(serializers.Serializer):
from_email = serializers.EmailField(required=True)
subject = serializers.CharField(required=True)
message = serializers.CharField(required=True)
def create(self, validated_data):
validated_data['recipient_list'] = (settings.EMAIL_HELPDESK,)
logger.info("Email %r" % validated_data)
send_mail(**validated_data)
class Meta:
model = ena_models.Notify
fields = '__all__'
class HistoryVideoSerializer(serializers.Serializer):
count = serializers.SerializerMethodField()
date = serializers.SerializerMethodField()
duration = serializers.IntegerField()
url = serializers.URLField()
image_url = serializers.URLField()
license_name = serializers.SerializerMethodField()
license_url = serializers.SerializerMethodField()
name = serializers.CharField(max_length=100)
progress = serializers.SerializerMethodField()
provider_name = serializers.CharField(max_length=100)
stream_url = serializers.URLField()
tags = serializers.SerializerMethodField()
def get_date(self, obj):
data = self.context.get(obj.id)
if data:
return data[0]
return '1970-01-01'
def get_count(self, obj):
data = self.context.get(obj.id)
if data:
return data[1]
return 1
def get_progress(self, obj):
data = self.context.get(obj.id)
if data:
return data[2]
return 1
def get_license_name(self, obj):
value = obj.license_name
if value is None or len(value) == 0:
return None
return value
def get_license_url(self, obj):
value = obj.license_url
if value is None or len(value) == 0:
return None
return value
def get_tags(self, obj):
sorted_categories = sorted(
obj.categories,
key=lambda cat: obj.categories.get(cat, 'weight', default=0))
return ','.join([cat.name for cat in sorted_categories])
class OfficeCSVSerializer(serializers.ModelSerializer):
status = serializers.CharField(source='get_status_display')
kind = serializers.CharField(source='get_kind_display')
class Meta:
model = Office
fields = [
'id',
'nomen',
'name',
'status',
'kind',
'short_name',
]
class ShipmentTagCreateSerializer(ShipmentTagSerializer):
shipment_id = serializers.CharField(required=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.initial_data = self.initial_data.copy()
self.initial_data.update(
shipment_id=self.context['view'].kwargs['shipment_pk'])
if settings.PROFILES_ENABLED:
self.initial_data.update(
owner_id=get_owner_id(self.context['request']))
class Meta:
model = ShipmentTag
fields = (
'owner_id',
'shipment_id',
'tag_type',
'tag_value',
)
validators = [
UniqueTogetherValidator(
queryset=ShipmentTag.objects.all(),
fields=['shipment_id', 'tag_type', 'tag_value'],
message=
'This shipment already has a tag with the provided [tag_type] and [tag_value].'
)
]
class IndicatorSerializer(serializers.HyperlinkedModelSerializer):
unit_name = serializers.CharField(source='unit.name', read_only=True)
included_serializers = {
'plans': 'actions.api.PlanSerializer',
'levels': IndicatorLevelSerializer,
'categories': 'actions.api.CategorySerializer',
'unit': UnitSerializer,
'estimates': 'indicators.api.IndicatorEstimateSerializer',
'latest_graph': IndicatorGraphSerializer,
'related_effects': 'indicators.api.RelatedIndicatorSerializer',
'related_causes': 'indicators.api.RelatedIndicatorSerializer',
'actions': 'actions.api.ActionSerializer',
}
class Meta:
model = Indicator
fields = (
'name',
'unit',
'unit_name',
'levels',
'plans',
'description',
'categories',
'time_resolution',
'estimates',
'latest_graph',
'actions',
'related_effects',
'related_causes',
'updated_at',
)
class FlowResultsResponseSerializer(serializers.Serializer):
"""
FlowResultsResponseSerializer for handling publishing of Flow Results
Response package.
"""
id = serializers.CharField() # pylint: disable=invalid-name
responses = serializers.ListField()
class JSONAPIMeta: # pylint: disable=old-style-class,no-init,R0903
"""
JSON API metaclass.
"""
resource_name = 'responses'
def create(self, validated_data):
request = self.context['request']
responses = validated_data['responses']
xform = get_object_or_404(XForm, uuid=validated_data['id'])
processed = []
for submission in parse_responses(responses):
xml_file = BytesIO(dict2xform(
submission, xform.id_string, 'data').encode('utf-8'))
error, instance = safe_create_instance(
request.user.username, xml_file, [], None, request)
processed.append(instance.pk)
if error:
raise serializers.ValidationError(error)
return FlowResultsResponse(xform.uuid, responses)
def update(self, instance, validated_data):
pass
class StructureSerializer(serializers.ModelSerializer):
name = serializers.CharField(
max_length=255,
allow_blank=True,
trim_whitespace=True,
)
class Meta:
model = Structure
fields = (
'id',
# 'url',
'status',
'name',
'kind',
'bhs_id',
'chapter_code',
'chorus_name',
'preferred_name',
'phone',
'email',
'established_date',
'created',
'modified',
'parent',
)
def __init__(self, *args, **kwargs):
# super hates my additional kwargs
sparse = kwargs.pop('sparse', False)
version_serializer = kwargs.pop('version_serializer', False)
super(BaseShareSerializer, self).__init__(*args, **kwargs)
if sparse:
# clear the fields if they asked for sparse
self.fields.clear()
else:
# remove hidden fields
excluded_fields = ['change', 'sources']
for field_name in tuple(self.fields.keys()):
if 'version' in field_name or field_name in excluded_fields:
self.fields.pop(field_name)
# version specific fields
if version_serializer:
self.fields.update({
'action': serializers.CharField(max_length=10),
'persistent_id': serializers.IntegerField()
})
# add fields with improper names
self.fields.update({
'type': fields.TypeField(),
})
class TokenSerializer(
serializers.IncludedResourcesValidationMixin,
serializers.SparseFieldsetsMixin,
auth_serializers.TokenSerializer,
):
"""Set the pk of the instance to be the user's pk."""
token = serializers.CharField(read_only=True, source="_backup_key")
user = serializers.ResourceRelatedField(read_only=True)
class Meta(auth_serializers.TokenSerializer.Meta):
"""Serializer meta information."""
fields = ["token", "user"]
class JSONAPIMeta:
"""JSONAPI meta information."""
resource_name = "sessions"
def __init__(self, *args, **kwargs):
"""Set the pk of the instance to be the user's pk."""
super().__init__(*args, **kwargs)
if getattr(self, "instance", None):
self.instance._backup_key = self.instance.pk
self.instance.pk = self.context["request"].user.pk
class DemographicDataSerializer(UuidHyperlinkedModelSerializer):
resource_name = "demographics"
country = serializers.CharField(default="")
date_created = serializers.DateTimeField(read_only=True,
source="created_at")
url = serializers.HyperlinkedIdentityField(
view_name="api:demographicdata-detail", lookup_field="uuid")
class Meta:
model = DemographicData
fields = (
"url",
"number_of_children",
"child_birthdays",
"languages_spoken_at_home",
"number_of_guardians",
"number_of_guardians_explanation",
"race_identification",
"age",
"gender",
"education_level",
"spouse_education_level",
"annual_income",
"former_lookit_annual_income",
"lookit_referrer",
"number_of_books",
"additional_comments",
"country",
"state",
"density",
"extra",
"date_created",
"pk",
)
class ShipmentSerializer(FieldPermissionSerializerMixin, EnumSupportSerializerMixin, serializers.ModelSerializer):
"""
Serializer for a shipment object
"""
load_data = LoadShipmentSerializer(source='loadshipment', required=False)
geofences = GeofenceListField(child=serializers.CharField(), required=False)
state = UpperEnumField(TransitState, lenient=True, ints_as_names=True, required=False, read_only=True)
exception = UpperEnumField(ExceptionType, lenient=True, ints_as_names=True, required=False)
gtx_validation = UpperEnumField(GTXValidation, lenient=True, ints_as_names=True, required=False)
tags = PermissionResourceRelatedField(many=True, required=False, read_only=True, source='shipment_tags',
permission_classes=(AccessRequest.related_field_permission(
Endpoints.tags, PermissionLevel.READ_ONLY)(),))
permission_derivation = serializers.SerializerMethodField()
included_serializers = {
'ship_from_location': LocationSerializer,
'ship_to_location': LocationSerializer,
'bill_to_location': LocationSerializer,
'final_destination_location': LocationSerializer,
'load_data': LoadShipmentSerializer,
'device': DeviceSerializer,
'tags': ShipmentTagSerializer,
}
class Meta:
model = Shipment
exclude = ('version', 'background_data_hash_interval', 'manual_update_hash_interval', 'asset_physical_id')
read_only_fields = ('owner_id', 'contract_version', 'arrival_est', 'carrier_abbv') \
if settings.PROFILES_ENABLED else ('contract_version', 'arrival_est', 'carrier_abbv')
meta_fields = ('permission_derivation',)
class JSONAPIMeta:
included_resources = ['ship_from_location', 'ship_to_location', 'bill_to_location',
'final_destination_location', 'load_data', 'tags', ]
@property
def user(self):
return self.context['request'].user
@property
def auth(self):
return get_jwt_from_request(self.context['request'])
def validate_geofences(self, geofences):
for geofence in geofences:
if not validate_uuid4(geofence):
raise serializers.ValidationError(f'Invalid UUIDv4 {geofence} provided in Geofences')
# Deduplicate list
return list(set(geofences))
def get_permission_derivation(self, obj):
if ('request' in self.context and
obj.id in getattr(self.context['request'].user, 'access_request_shipments', [])):
return 'AccessRequest'
return 'OwnerOrPartyOrPermissionLink'
class CollectionSerializer(serializers.Serializer):
id = serializers.CharField(read_only=True)
title = serializers.CharField(required=True)
description = serializers.CharField(required=False, allow_blank=True)
tags = serializers.CharField(required=False, allow_blank=True)
settings = serializers.JSONField(required=False)
submission_settings = serializers.JSONField(required=False)
created_by_org = serializers.CharField(allow_blank=True, required=False)
created_by = RelationshipField(
related_view='user-detail',
related_view_kwargs={'user_id': '<created_by.pk>'},
)
date_created = serializers.DateTimeField(read_only=True)
date_updated = serializers.DateTimeField(read_only=True)
groups = RelationshipField(related_view='collection-group-list',
related_view_kwargs={'pk': '<pk>'})
items = RelationshipField(related_view='collection-item-list',
related_view_kwargs={'pk': '<pk>'})
class Meta:
model = Collection
fields = ['id', 'title', 'description', 'tags', 'created_by']
class JSONAPIMeta:
resource_name = 'collections'
def create(self, validated_data):
user = self.context['request'].user
collection = Collection.objects.create(created_by=user,
**validated_data)
assign_perm('api.approve_collection_items', user, collection)
return collection
def update(self, collection, validated_data):
collection.title = validated_data.get('title', collection.title)
collection.description = validated_data.get('description',
collection.description)
collection.tags = validated_data.get('tags', collection.tags)
collection.settings = validated_data.get('settings',
collection.settings)
collection.submission_settings = validated_data.get(
'submission_settings', collection.submission_settings)
collection.created_by_org = validated_data.get(
'created_by_org', collection.created_by_org)
collection.save()
return collection
class EmploymentSummarySerializer(BaseModelSerializer):
class Meta:
model = Employment
fields = ['id', 'url', 'created', 'updated', 'name', 'email', 'role']
create_only_fields = ['email']
name = serializers.CharField(source='user.get_full_name', read_only=True)
email = serializers.EmailField(source='user.email')
